/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import {
  numDefine98,
  numDefine99,
  numDefine100,
  numDefine101,
  numDefine102,
  numDefine103,
  numDefine128,
  numDefine140,
  numDefine107,
  numDefine111,
  numDefine145,
  numDefine146,
  numDefine147,
  numDefine148,
  numDefine108,
  numDefine109,
  numDefine110,
  numDefine104,
  numDefine105,
  numDefine106,
  numDefine28,
  numDefine2,
  numDefine13,
  numDefine19,
  numDefine18,
  numDefine3,
  numDefine16,
  numDefine5,
  numDefine6,
  numDefine7,
  numDefine8,
  numDefine135,
  numDefine136,
  numDefine257,
  numDefine65537,
  numDefine137,
  numDefine138,
  numDefine139,
  numDefine141,
  numDefine142,
  numDefine143,
  numDefine144,
  numDefine149,
  numDefine151,
  numDefine152,
  numDefine153,
  numDefine155,
  numDefine156,
  numDefine157,
  numDefine159,
  numDefine160,
  numDefine161,
  numDefine163,
  numDefine164,
  numDefine165,
  numDefine172,
  numDefine173,
  numDefine170,
  numDefine171,
  numDefine169,
  numDefineFloat265,
  numDefine29,
  numDefine20,
  numDefine14,
  numDefine72,
  numDefine73,
  numDefine74,
  numDefine75,
  numDefine76,
  numDefine77,
  numDefine78,
  numDefine79,
  numDefine80,
  numDefine81,
  numDefine82,
  numDefine83,
  numDefine84,
  numDefine85,
  numDefine86,
  numDefine87,
  numDefine88,
  numDefine89,
  numDefine90,
  numDefine91,
  numDefine92,
  numDefine93,
  numDefine94,
  numDefine95,
  numDefine96,
  numDefine97,
  numDefine30,
  numDefine21,
  numDefine31,
  numDefine22,
  numDefine32,
  numDefine23,
  numDefine33,
  numDefine10,
  numDefine9,
  numDefine4,
  numDefine15,
  numDefine11,
  numDefine48,
  numDefineNeg2,
  numDefine46,
  numDefineNeg8,
  numDefine56,
  numDefine64,
  numDefine58,
  numDefine65535,
  numDefineNeg16,
  numDefine27,
  numDefine17,
  numDefine12,
  numDefine255,
  numDefineNeg24,
  numDefine54,
  numDefineNeg4,
  numDefine24,
  numDefineNeg40,
  numDefineNeg6,
  numDefineNeg3,
  numDefine40,
  numDefine47,
  numDefine36,
  numDefine69,
  numDefine61,
  numDefine50,
  numDefine25,
  numDefine67,
  numDefine26,
  numDefine63,
  numDefine129,
  numDefine38,
  numDefine42,
  numDefine71,
  numDefine39,
  numDefine45,
  numDefine34,
  numDefine43,
  numDefine44,
  numDefine184,
  numDefine49,
  numDefine68,
  numDefine65,
  numDefine41,
  numDefine124,
  numDefine66,
  numDefine57,
  numDefine52,
  numDefine51,
  numDefine35,
  numDefine37,
  numDefine113,
  numDefine70,
  numDefine120,
  numDefine256,
  numDefine53,
  numDefine60,
  numDefine1000,
  numDefineNeg7,
  numDefineNeg5,
  numDefine263,
  numDefineNeg48,
  numDefineNeg136,
  numDefine114,
  numDefine119,
  numDefine122,
  numDefine112,
  numDefineNeg102,
  numDefineNeg144,
  numDefineNeg36,
  numDefine62,
  numDefine115,
  numDefine117,
  numDefine167,
  numDefine176,
  numDefineNeg134,
  numDefine121,
  numDefineNeg10,
  numDefineNeg32,
  numDefineNeg80,
  numDefineNeg20,
  numDefineNeg64,
  numDefineNeg22,
  numDefine131,
  numDefineNeg120,
  numDefineN6,
  numDefine280,
  numDefine200,
  numDefineNeg96,
  numDefineNeg168,
  numDefineNeg152,
  numDefineNeg38,
  numDefine55,
  numDefine59,
  numDefine492,
  numDefine220,
  numDefine246,
  numDefine264,
  numDefine245,
  numDefine244,
  numDefineNeg176,
  numDefineNeg44,
  numDefineNeg18,
  numDefineNeg288,
  numDefineNeg280,
  numDefineNeg272,
  numDefineNeg264,
  numDefineNeg156,
  numDefineNeg76,
  numDefine116,
  numDefineNeg56,
  numDefine127,
  numDefine126,
  numDefineNeg88,
  numDefineNeg34,
  numDefineNeg42,
  numDefine279,
  numDefine277,
  numDefineNeg178,
  numDefineNeg186,
  numDefineNeg182,
  numDefineNeg194,
  numDefineNeg191,
  numDefineNeg192,
  numDefineNeg193,
  numDefineNeg190,
  numDefineFloat1257,
  numDefine132,
  numDefine133,
  numDefineNeg296,
  numDefineNeg74,
  numDefineNeg128,
  numDefine214,
  numDefine219,
  numDefine233,
  numDefineNeg132,
  numDefine284,
  numDefine174,
  numDefine175,
  numDefine242,
  numDefine278,
  numDefine281,
  numDefine204,
  numDefineNeg72,
  numDefineNeg14,
  numDefineNeg104,
  numDefine276,
  numDefineFloat742,
  numDefineNeg336,
  numDefineNeg232,
  numDefineNeg68,
  numDefineNeg28,
  numDefineNeg200,
  numDefineNeg448,
  numDefineNeg328,
  numDefineNeg424,
  numDefineNeg106,
  numDefineNeg440,
  numDefineNeg110,
  numDefineNeg504,
  numDefineNeg126,
  numDefineNeg408,
  numDefineNeg164,
  numDefineNeg142,
  numDefineNeg568,
  numDefineNeg26,
  numDefineNeg70,
  numDefineNeg58,
  numDefineNeg312,
  numDefineNeg78,
  numDefineNeg760,
  numDefineNeg98,
  numDefineNeg82,
  numDefineNeg9,
  numDefineNeg166,
  numDefineNeg174,
  numDefineNeg158,
  numDefineNeg616,
  numDefineNeg154,
  numDefine228,
  numDefine210,
  numDefine209,
  numDefine208,
  numDefine83646,
  numDefineNeg30,
  numDefineNeg392,
  numDefineNeg456,
  numDefineNeg114,
  numDefineNeg130,
  numDefineNeg696,
  numDefineNeg118,
  numDefineNeg472,
  numDefine118,
  numDefine130,
  numDefine134,
  numDefineNeg131,
  numDefineNeg129,
  numDefineNeg133,
  numDefineNeg138,
  numDefineNeg127,
  numDefineNeg146,
  numDefine584,
  numDefine288,
  numDefine125,
  numDefine212,
  numDefine168,
  numDefineNeg552,
  numDefine178,
  numDefine232,
  numDefineNeg584,
  numDefine216,
  numDefine194,
  numDefine64525,
  numDefine04223,
  numDefine320,
  numDefine260,
  numDefine196,
  numDefine496,
  numDefineNeg824,
  numDefine6144,
  numDefineFloat283,
  numDefineNeg536,
  numDefine265,
  numDefine266,
  numDefine267,
  numDefine268,
  numDefine269,
  numDefine270,
  numDefine271,
  numDefine272,
  numDefine273,
  numDefine274,
  numDefine275,
  numDefine282,
  numDefine283,
  numDefine285,
  numDefine286,
  numDefine287,
  numDefine289,
  numDefine290,
  numDefine291,
  numDefine292,
  numDefine293,
  numDefine294,
  numDefine1164,
  numDefine230,
  numDefine231,
  numDefine247,
  numDefineFloat809,
  numDefine296,
  numDefine297,
  numDefineNeg600,
  numDefineNeg150,
  numDefine215,
  numDefineNeg632,
  numDefine203,
  numDefine205,
  numDefine206,
  numDefine207,
  numDefine211,
  numDefine213,
  numDefine217,
  numDefine218,
  numDefine221,
  numDefine222,
  numDefine223,
  numDefine224,
  numDefine225,
  numDefine226,
  numDefine227,
  numDefine229,
  numDefine234,
  numDefine924,
  numDefine876,
  numDefine812,
  numDefineNeg712,
  numDefineNeg728,
  numDefineNeg744,
  numDefine480,
  numDefine444,
  numDefineFloat566,
  numDefineFloat091,
  numDefine53216,
  numDefine1186,
  numDefine1185,
  numDefine1129,
  numDefine813,
  numDefineNeg88609,
  numDefine95039,
  numDefine64608,
  numDefine97773,
  numDefine93162,
  numDefine81770,
  numDefine44395,
  numDefine16192,
  numDefine54297,
  numDefine45650,
  numDefine41027,
  numDefine06843,
  numDefine30011,
  numDefineNeg53637
} from './mandreel-part1/Class/DevNumber';

import {
  mallocNew,
  uint,
  functionTable,
  free,
  zdlPv,
  assertNew,
  getTimeOfDay,
  sqrtf,
  sinf,
  powf,
  znwj,
  abort,
  zdaPv,
  cosf,
  zn15CProfileManager13StartProfileEPKc,
  zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf,
  zn12CProfileNode5ResetEv
} from './commonFile';
import { commonVariable, heapClassInst } from './mandreel-part1/Class/CommonClassFile';
import {
  zn16btCollisionWorld14debugDrawWorldEv,
  zn16btCollisionWorld18addCollisionObjectEP17btCollisionObjectss,
  zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject,
  zn16btCollisionWorld25serializeCollisionObjectsEP12btSerializer,
  zn16btCollisionWorldD2Ev,
  znk16btCollisionWorld15convexSweepTestEPK13btConvexShapeRK11btTransformS5RNS20ConvexResultCallbackEf,
  znk17btCollisionObject9serializeEPvP12btSerializer
} from './mandreelFile3';
import {
  zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi,
  zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi
} from './mandreelFile4';
import {
  zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0,
  zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint,
  zn16btCollisionWorld27ClosestConvexResultCallback15addSingleResultERNS17LocalConvexResultEb,
  znk21btConeTwistConstraint16GetPointForAngleEff
} from './mandreelFile5';

import {
  gNumSplitImpulseRecoveries,
  ztv35btSequentialImpulseConstraintSolver,
  gNumAlignedFree,
  zn15CProfileManager11CurrentNodeE,
  zl13gProfileClock2E0,
  twoEStr753,
  twoEStr652,
  twoEStr551,
  memcpy,
  twoEStr955,
  twoEStr1056,
  gNumAlignedAllocs,
  zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed,
  zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed,
  ztv11btRigidBody,
  twoEStr1157,
  twoEStr854,
  twoEStr289,
  ztvn16btCollisionWorld27ClosestConvexResultCallbackE,
  ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback,
  twoEStr87,
  twoEStr188,
  twoEStr794,
  twoEStr895,
  ztv34btClosestNotMeConvexResultCallback,
  ztv13btSphereShape,
  ztv13btConvexShape,
  gNumClampedCcdMotions,
  twoEStr996,
  twoEStr155,
  twoEStr2157,
  twoEStr1156,
  twoEStr3158,
  twoEStr1097,
  gDisableDeactivation,
  twoEStr1198,
  zn15CProfileManager12FrameCounterE,
  twoEStr13100,
  twoEStr1461,
  twoEStr1299,
  twoEStr1562,
  twoEStr16101,
  ztv15btDynamicsWorld,
  ztv23btDiscreteDynamicsWorld,
  ztv17btCollisionObject,
  twoEStr248,
  twoEStr34955,
  twoEStr414,
  zn15CProfileManager4RootE,
  twoEStr729,
  zn4RwL12RwCatlistE2E0,
  zn4RwL12RwCatlistE2E1,
  zn4RwL12RwCatlistE2E2,
  ztvn4Rw10RwFacetE,
  zzn4Rw10RwFacetD4EvE9destroyed,
  twoEStr450
} from './commonFile';
import { zn4Rw10RwThrowEiz } from './mandreelFile7';
import { zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE, zn11btRigidBody19updateInertiaTensorEv } from './mandreelFile8';

function zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + numDefine2];
  r1 = r1 >> numDefine2;
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + 1];
  r2 = r2 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine4];
  f1 = heapClassInst.heapFloat[r0 + numDefine126];
  f2 = heapClassInst.heapFloat[r1 + numDefine5];
  f3 = heapClassInst.heapFloat[r0 + numDefine127];
  f4 = heapClassInst.heapFloat[r1];
  f5 = heapClassInst.heapFloat[r0 + numDefine130];
  f6 = heapClassInst.heapFloat[r1 + 1];
  f7 = heapClassInst.heapFloat[r0 + numDefine131];
  f8 = heapClassInst.heapFloat[r2 + numDefine126];
  f9 = heapClassInst.heapFloat[r2 + numDefine127];
  f10 = heapClassInst.heapFloat[r1 + numDefine6];
  f11 = heapClassInst.heapFloat[r0 + numDefine128];
  f1 = f0 * f1;
  f3 = f2 * f3;
  f4 = f4 * f5;
  f5 = f6 * f7;
  f6 = heapClassInst.heapFloat[r1 + numDefine2];
  f7 = heapClassInst.heapFloat[r0 + numDefine132];
  f12 = heapClassInst.heapFloat[r1 + numDefine8];
  f13 = heapClassInst.heapFloat[r2 + numDefine130];
  f14 = heapClassInst.heapFloat[r1 + numDefine9];
  f15 = heapClassInst.heapFloat[r2 + numDefine131];
  f16 = heapClassInst.heapFloat[r2 + numDefine128];
  f1 = f1 + f3;
  f3 = f10 * f11;
  f4 = f4 + f5;
  f5 = f6 * f7;
  f6 = f12 * f13;
  f7 = f14 * f15;
  f11 = heapClassInst.heapFloat[r1 + numDefine10];
  f12 = heapClassInst.heapFloat[r2 + numDefine132];
  f8 = f0 * f8;
  f9 = f2 * f9;
  f13 = heapClassInst.heapFloat[r1 + numDefine21];
  f14 = heapClassInst.heapFloat[r1 + numDefine30];
  f1 = f1 + f3;
  f3 = f4 + f5;
  f4 = f6 + f7;
  f5 = f11 * f12;
  f6 = f8 + f9;
  f7 = f10 * f16;
  f8 = heapClassInst.heapFloat[r1 + numDefine29];
  f9 = f13 * f14;
  f1 = f1 + f3;
  f3 = heapClassInst.heapFloat[r1 + numDefine23];
  f4 = f4 + f5;
  f5 = f6 + f7;
  f4 = f4 - f5;
  f5 = f8 - f9;
  f1 = f3 * f1;
  f1 = f5 - f1;
  f3 = f3 * f4;
  f1 = f1 - f3;
  f3 = heapClassInst.heapFloat[r1 + numDefine31];
  f4 = f13 + f1;
  if (f3 > f4) {
    f1 = f3 - f13;
    f4 = f3;
  }
  heapClassInst.heapFloat[r1 + numDefine21] = f4;
  f3 = heapClassInst.heapFloat[r0 + numDefine84];
  f4 = 0;
  if (!(f3 === f4)) {
    f3 = heapClassInst.heapFloat[r0 + numDefine138];
    f0 = f0 * f3;
    f0 = f0 * f1;
    f3 = heapClassInst.heapFloat[r0 + numDefine126];
    f5 = heapClassInst.heapFloat[r0 + numDefine139];
    f6 = heapClassInst.heapFloat[r0 + numDefine140];
    f0 = f3 + f0;
    f2 = f2 * f5;
    heapClassInst.heapFloat[r0 + numDefine126] = f0;
    f0 = f2 * f1;
    f2 = heapClassInst.heapFloat[r0 + numDefine127];
    f0 = f2 + f0;
    f2 = f10 * f6;
    heapClassInst.heapFloat[r0 + numDefine127] = f0;
    f0 = f2 * f1;
    f2 = heapClassInst.heapFloat[r0 + numDefine128];
    f0 = f2 + f0;
    heapClassInst.heapFloat[r0 + numDefine128] = f0;
    f0 = heapClassInst.heapFloat[r0 + numDefine134];
    f0 = f0 * f1;
    f2 = heapClassInst.heapFloat[r1 + numDefine12];
    f3 = heapClassInst.heapFloat[r0 + numDefine136];
    f5 = heapClassInst.heapFloat[r0 + numDefine135];
    f0 = f2 * f0;
    f2 = heapClassInst.heapFloat[r0 + numDefine130];
    f6 = heapClassInst.heapFloat[r1 + numDefine14];
    f7 = heapClassInst.heapFloat[r1 + numDefine13];
    f0 = f2 + f0;
    f2 = f5 * f1;
    heapClassInst.heapFloat[r0 + numDefine130] = f0;
    f0 = f7 * f2;
    f2 = heapClassInst.heapFloat[r0 + numDefine131];
    f0 = f2 + f0;
    f2 = f3 * f1;
    heapClassInst.heapFloat[r0 + numDefine131] = f0;
    f0 = f6 * f2;
    f2 = heapClassInst.heapFloat[r0 + numDefine132];
    f0 = f2 + f0;
    heapClassInst.heapFloat[r0 + numDefine132] = f0;
  }
  f0 = heapClassInst.heapFloat[r2 + numDefine84];
  if (!(f0 === f4)) {
    f0 = heapClassInst.heapFloat[r1 + numDefine4];
    f2 = heapClassInst.heapFloat[r2 + numDefine138];
    f0 = f2 * f0;
    f0 = f0 * f1;
    f2 = heapClassInst.heapFloat[r2 + numDefine126];
    f3 = heapClassInst.heapFloat[r1 + numDefine5];
    f4 = heapClassInst.heapFloat[r2 + numDefine139];
    f5 = heapClassInst.heapFloat[r1 + numDefine6];
    f6 = heapClassInst.heapFloat[r2 + numDefine140];
    f0 = f2 - f0;
    f2 = f4 * f3;
    heapClassInst.heapFloat[r2 + numDefine126] = f0;
    f0 = f2 * f1;
    f2 = heapClassInst.heapFloat[r2 + numDefine127];
    f0 = f2 - f0;
    f2 = f6 * f5;
    heapClassInst.heapFloat[r2 + numDefine127] = f0;
    f0 = f2 * f1;
    f2 = heapClassInst.heapFloat[r2 + numDefine128];
    f0 = f2 - f0;
    heapClassInst.heapFloat[r2 + numDefine128] = f0;
    f0 = heapClassInst.heapFloat[r2 + numDefine134];
    f0 = f0 * f1;
    f2 = heapClassInst.heapFloat[r1 + numDefine16];
    f3 = heapClassInst.heapFloat[r2 + numDefine136];
    f4 = heapClassInst.heapFloat[r2 + numDefine135];
    f0 = f2 * f0;
    f2 = heapClassInst.heapFloat[r2 + numDefine130];
    f5 = heapClassInst.heapFloat[r1 + numDefine18];
    f6 = heapClassInst.heapFloat[r1 + numDefine17];
    f0 = f2 + f0;
    f2 = f4 * f1;
    heapClassInst.heapFloat[r2 + numDefine130] = f0;
    f0 = f6 * f2;
    f2 = heapClassInst.heapFloat[r2 + numDefine131];
    f0 = f2 + f0;
    f1 = f3 * f1;
    heapClassInst.heapFloat[r2 + numDefine131] = f0;
    f0 = f5 * f1;
    f1 = heapClassInst.heapFloat[r2 + numDefine132];
    f0 = f1 + f0;
    heapClassInst.heapFloat[r2 + numDefine132] = f0;
  }
  return;
}

function zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r0 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r0 + numDefine33];
  f1 = 0;
  if (!(f0 === f1)) {
    r1 = heapClassInst.heap32[fp];
    r2 = heapClassInst.heap32[fp + 1];
    r3 = gNumSplitImpulseRecoveries;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r3];
    r4 = (r4 + 1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r3] = r4;
    r2 = r2 >> numDefine2;
    f2 = heapClassInst.heapFloat[r0 + numDefine4];
    f3 = heapClassInst.heapFloat[r1 + numDefine142];
    f4 = heapClassInst.heapFloat[r0 + numDefine5];
    f5 = heapClassInst.heapFloat[r1 + numDefine143];
    f6 = heapClassInst.heapFloat[r0];
    f7 = heapClassInst.heapFloat[r1 + numDefine146];
    f8 = heapClassInst.heapFloat[r0 + 1];
    f9 = heapClassInst.heapFloat[r1 + numDefine147];
    f10 = heapClassInst.heapFloat[r2 + numDefine142];
    f11 = heapClassInst.heapFloat[r2 + numDefine143];
    f12 = heapClassInst.heapFloat[r0 + numDefine6];
    f13 = heapClassInst.heapFloat[r1 + numDefine144];
    f3 = f2 * f3;
    f5 = f4 * f5;
    f6 = f6 * f7;
    f7 = f8 * f9;
    f8 = heapClassInst.heapFloat[r0 + numDefine2];
    f9 = heapClassInst.heapFloat[r1 + numDefine148];
    f14 = heapClassInst.heapFloat[r0 + numDefine8];
    f15 = heapClassInst.heapFloat[r2 + numDefine146];
    f16 = heapClassInst.heapFloat[r0 + numDefine9];
    f17 = heapClassInst.heapFloat[r2 + numDefine147];
    f18 = heapClassInst.heapFloat[r2 + numDefine144];
    f3 = f3 + f5;
    f5 = f12 * f13;
    f6 = f6 + f7;
    f7 = f8 * f9;
    f8 = f14 * f15;
    f9 = f16 * f17;
    f13 = heapClassInst.heapFloat[r0 + numDefine10];
    f14 = heapClassInst.heapFloat[r2 + numDefine148];
    f10 = f2 * f10;
    f11 = f4 * f11;
    f15 = heapClassInst.heapFloat[r0 + numDefine20];
    f16 = heapClassInst.heapFloat[r0 + numDefine30];
    f3 = f3 + f5;
    f5 = f6 + f7;
    f6 = f8 + f9;
    f7 = f13 * f14;
    f8 = f10 + f11;
    f9 = f12 * f18;
    f10 = f15 * f16;
    f3 = f3 + f5;
    f5 = heapClassInst.heapFloat[r0 + numDefine23];
    f6 = f6 + f7;
    f7 = f8 + f9;
    f6 = f6 - f7;
    f0 = f0 - f10;
    f3 = f5 * f3;
    f0 = f0 - f3;
    f3 = f5 * f6;
    f0 = f0 - f3;
    f3 = heapClassInst.heapFloat[r0 + numDefine31];
    f5 = f15 + f0;
    if (f3 > f5) {
      f0 = f3 - f15;
      f5 = f3;
    }
    heapClassInst.heapFloat[r0 + numDefine20] = f5;
    f3 = heapClassInst.heapFloat[r1 + numDefine84];
    if (!(f3 === f1)) {
      f3 = heapClassInst.heapFloat[r1 + numDefine138];
      f2 = f2 * f3;
      f2 = f2 * f0;
      f3 = heapClassInst.heapFloat[r1 + numDefine142];
      f5 = heapClassInst.heapFloat[r1 + numDefine139];
      f6 = heapClassInst.heapFloat[r1 + numDefine140];
      f2 = f3 + f2;
      f3 = f4 * f5;
      heapClassInst.heapFloat[r1 + numDefine142] = f2;
      f2 = f3 * f0;
      f3 = heapClassInst.heapFloat[r1 + numDefine143];
      f2 = f3 + f2;
      f3 = f12 * f6;
      heapClassInst.heapFloat[r1 + numDefine143] = f2;
      f2 = f3 * f0;
      f3 = heapClassInst.heapFloat[r1 + numDefine144];
      f2 = f3 + f2;
      heapClassInst.heapFloat[r1 + numDefine144] = f2;
      f2 = heapClassInst.heapFloat[r1 + numDefine134];
      f2 = f2 * f0;
      f3 = heapClassInst.heapFloat[r0 + numDefine12];
      f4 = heapClassInst.heapFloat[r1 + numDefine136];
      f5 = heapClassInst.heapFloat[r1 + numDefine135];
      f2 = f3 * f2;
      f3 = heapClassInst.heapFloat[r1 + numDefine146];
      f6 = heapClassInst.heapFloat[r0 + numDefine14];
      f7 = heapClassInst.heapFloat[r0 + numDefine13];
      f2 = f3 + f2;
      f3 = f5 * f0;
      heapClassInst.heapFloat[r1 + numDefine146] = f2;
      f2 = f7 * f3;
      f3 = heapClassInst.heapFloat[r1 + numDefine147];
      f2 = f3 + f2;
      f3 = f4 * f0;
      heapClassInst.heapFloat[r1 + numDefine147] = f2;
      f2 = f6 * f3;
      f3 = heapClassInst.heapFloat[r1 + numDefine148];
      f2 = f3 + f2;
      heapClassInst.heapFloat[r1 + numDefine148] = f2;
    }
    f2 = heapClassInst.heapFloat[r2 + numDefine84];
    if (!(f2 === f1)) {
      f1 = heapClassInst.heapFloat[r0 + numDefine4];
      f2 = heapClassInst.heapFloat[r2 + numDefine138];
      f1 = f2 * f1;
      f1 = f1 * f0;
      f2 = heapClassInst.heapFloat[r2 + numDefine142];
      f3 = heapClassInst.heapFloat[r0 + numDefine5];
      f4 = heapClassInst.heapFloat[r2 + numDefine139];
      f5 = heapClassInst.heapFloat[r0 + numDefine6];
      f6 = heapClassInst.heapFloat[r2 + numDefine140];
      f1 = f2 - f1;
      f2 = f4 * f3;
      heapClassInst.heapFloat[r2 + numDefine142] = f1;
      f1 = f2 * f0;
      f2 = heapClassInst.heapFloat[r2 + numDefine143];
      f1 = f2 - f1;
      f2 = f6 * f5;
      heapClassInst.heapFloat[r2 + numDefine143] = f1;
      f1 = f2 * f0;
      f2 = heapClassInst.heapFloat[r2 + numDefine144];
      f1 = f2 - f1;
      heapClassInst.heapFloat[r2 + numDefine144] = f1;
      f1 = heapClassInst.heapFloat[r2 + numDefine134];
      f1 = f1 * f0;
      f2 = heapClassInst.heapFloat[r0 + numDefine16];
      f3 = heapClassInst.heapFloat[r2 + numDefine136];
      f4 = heapClassInst.heapFloat[r2 + numDefine135];
      f1 = f2 * f1;
      f2 = heapClassInst.heapFloat[r2 + numDefine146];
      f5 = heapClassInst.heapFloat[r0 + numDefine18];
      f6 = heapClassInst.heapFloat[r0 + numDefine17];
      f1 = f2 + f1;
      f2 = f4 * f0;
      heapClassInst.heapFloat[r2 + numDefine146] = f1;
      f1 = f6 * f2;
      f2 = heapClassInst.heapFloat[r2 + numDefine147];
      f1 = f2 + f1;
      f0 = f3 * f0;
      heapClassInst.heapFloat[r2 + numDefine147] = f1;
      f0 = f5 * f0;
      f1 = heapClassInst.heapFloat[r2 + numDefine148];
      f0 = f1 + f0;
      heapClassInst.heapFloat[r2 + numDefine148] = f0;
    }
  }
  return;
}

function z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  if (!(r0 === 0)) {
    r0 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r0 + numDefine45];
    if (r1 !== 0) {
      r1 = heapClassInst.heap32[fp + 1];
      r1 = r1 >> numDefine2;
      f0 = heapClassInst.heapFloat[r1];
      f1 = heapClassInst.heapFloat[r0 + numDefine2];
      f2 = heapClassInst.heapFloat[r0 + 1];
      f3 = heapClassInst.heapFloat[r1 + 1];
      f4 = heapClassInst.heapFloat[r0 + numDefine6];
      f5 = heapClassInst.heapFloat[r0 + numDefine5];
      f6 = heapClassInst.heapFloat[r0 + numDefine3];
      f7 = heapClassInst.heapFloat[r0 + numDefine7];
      f8 = f2 * f0;
      f9 = f5 * f3;
      f10 = f1 * f0;
      f11 = f4 * f3;
      f12 = heapClassInst.heapFloat[r1 + numDefine2];
      f13 = heapClassInst.heapFloat[r0 + numDefine10];
      f14 = heapClassInst.heapFloat[r0 + numDefine9];
      f15 = heapClassInst.heapFloat[r0 + numDefine11];
      f8 = f8 + f9;
      f9 = f14 * f12;
      f10 = f10 + f11;
      f11 = f13 * f12;
      f0 = f6 * f0;
      f3 = f7 * f3;
      f8 = f8 + f9;
      f9 = heapClassInst.heapFloat[r0 + numDefine41];
      f10 = f10 + f11;
      f11 = heapClassInst.heapFloat[r0 + numDefine42];
      f0 = f0 + f3;
      f3 = f15 * f12;
      f8 = f8 * f9;
      f9 = f10 * f11;
      f10 = heapClassInst.heapFloat[r0 + numDefine43];
      f0 = f0 + f3;
      f0 = f0 * f10;
      f2 = f2 * f8;
      f1 = f1 * f9;
      f3 = f5 * f8;
      f4 = f4 * f9;
      f1 = f2 + f1;
      f2 = f6 * f0;
      f5 = f14 * f8;
      f6 = f13 * f9;
      f3 = f3 + f4;
      f4 = f7 * f0;
      f1 = f1 + f2;
      f2 = f5 + f6;
      f0 = f15 * f0;
      f3 = f3 + f4;
      heapClassInst.heapFloat[r1] = f1;
      f0 = f2 + f0;
      heapClassInst.heapFloat[r1 + 1] = f3;
      heapClassInst.heapFloat[r1 + numDefine2] = f0;
      heapClassInst.heap32[r1 + numDefine3] = 0;
      return;
    }
  }
  return;
}

function zn35btSequentialImpulseConstraintSolver5resetEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine31] = 0;
  return;
}

function zn35btSequential(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine7];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine11];
  repeat1: do {
    if (!(r2 === 0)) {
      r2 = heapClassInst.heap32[fp];
      r0 = heapClassInst.heapU8[r0 + numDefine61];
      r3 = heapClassInst.heap32[r1 + numDefine5];
      r0 = r0 & 1;
      if (r0 !== 0) {
        if (!(r3 < 1)) {
          r0 = 0;
          repeat6: while (true) {
            r3 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + numDefine2];
            if (!(r4 < 1)) {
              r5 = 0;
              repeat10: while (true) {
                r6 = heapClassInst.heap32[r3 + numDefine19];
                r7 = r5 << numDefine2;
                r6 = (r6 + r7) | 0;
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6];
                r6 = (r6 * numDefine136) | 0;
                r7 = heapClassInst.heap32[r3 + numDefine4];
                r6 = (r7 + r6) | 0;
                r7 = r6 >> numDefine2;
                r8 = heapClassInst.heap32[r7 + numDefine27];
                r7 = heapClassInst.heap32[r7 + numDefine26];
                heapClassInst.heap32[g0] = r7;
                heapClassInst.heap32[g0 + 1] = r8;
                heapClassInst.heap32[g0 + numDefine2] = r6;
                r5 = (r5 + 1) | 0;
                zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(i7);
                if (!(r4 !== r5)) {
                  break repeat10;
                }
              }
            }
            r0 = (r0 + 1) | 0;
            r3 = heapClassInst.heap32[r1 + numDefine5];
            if (r3 > r0) {
              continue repeat6;
            } else {
              break repeat1;
            }
          }
        }
      } else {
        if (r3 > 0) {
          r0 = 0;
          repeat15: while (true) {
            r3 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + numDefine2];
            if (!(r4 < 1)) {
              r5 = 0;
              repeat19: while (true) {
                r6 = heapClassInst.heap32[r3 + numDefine19];
                r7 = r5 << numDefine2;
                r6 = (r6 + r7) | 0;
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6];
                r6 = (r6 * numDefine136) | 0;
                r7 = heapClassInst.heap32[r3 + numDefine4];
                r6 = (r7 + r6) | 0;
                r7 = r6 >> numDefine2;
                r8 = heapClassInst.heap32[r7 + numDefine27];
                r7 = heapClassInst.heap32[r7 + numDefine26];
                heapClassInst.heap32[g0] = r7;
                heapClassInst.heap32[g0 + 1] = r8;
                heapClassInst.heap32[g0 + numDefine2] = r6;
                r5 = (r5 + 1) | 0;
                zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint(i7);
                if (!(r4 !== r5)) {
                  break repeat19;
                }
              }
            }
            r0 = (r0 + 1) | 0;
            r3 = heapClassInst.heap32[r1 + numDefine5];
            if (r3 > r0) {
              continue repeat15;
            } else {
              break repeat1;
            }
          }
        }
      }
    }
  } while (false);
  return;
}

function zn35btSequentialImpulseConstraintSolverD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv35btSequentialImpulseConstraintSolver;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine29];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine120];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine29] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine120] = r1;
  heapClassInst.heap32[r2 + numDefine29] = 0;
  heapClassInst.heap32[r2 + numDefine27] = 0;
  heapClassInst.heap32[r2 + numDefine28] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine24];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine100];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine24] = 0;
  }
  heapClassInst.heap8[r0 + numDefine100] = r1;
  heapClassInst.heap32[r2 + numDefine24] = 0;
  heapClassInst.heap32[r2 + numDefine22] = 0;
  heapClassInst.heap32[r2 + numDefine23] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine19];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine80];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine19] = 0;
  }
  heapClassInst.heap8[r0 + numDefine80] = r1;
  heapClassInst.heap32[r2 + numDefine19] = 0;
  heapClassInst.heap32[r2 + numDefine17] = 0;
  heapClassInst.heap32[r2 + numDefine18] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine60];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine14] = 0;
  }
  heapClassInst.heap8[r0 + numDefine60] = r1;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine40];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine9] = 0;
  }
  heapClassInst.heap8[r0 + numDefine40] = r1;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  return;
}

function zn35btSequentialImpulseConstraintSolverD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv35btSequentialImpulseConstraintSolver;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine29];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine120];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine29] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine120] = r1;
  heapClassInst.heap32[r2 + numDefine29] = 0;
  heapClassInst.heap32[r2 + numDefine27] = 0;
  heapClassInst.heap32[r2 + numDefine28] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine24];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine100];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine24] = 0;
  }
  heapClassInst.heap8[r0 + numDefine100] = r1;
  heapClassInst.heap32[r2 + numDefine24] = 0;
  heapClassInst.heap32[r2 + numDefine22] = 0;
  heapClassInst.heap32[r2 + numDefine23] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine19];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine80];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine19] = 0;
  }
  heapClassInst.heap8[r0 + numDefine80] = r1;
  heapClassInst.heap32[r2 + numDefine19] = 0;
  heapClassInst.heap32[r2 + numDefine17] = 0;
  heapClassInst.heap32[r2 + numDefine18] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine14];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine60];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine14] = 0;
  }
  heapClassInst.heap8[r0 + numDefine60] = r1;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine12] = 0;
  heapClassInst.heap32[r2 + numDefine13] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine9];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine40];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine9] = 0;
  }
  heapClassInst.heap8[r0 + numDefine40] = r1;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine7] = 0;
  heapClassInst.heap32[r2 + numDefine8] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine20];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine4] = 0;
  }
  heapClassInst.heap8[r0 + numDefine20] = r1;
  heapClassInst.heap32[r2 + numDefine4] = 0;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn35btSolver10Solve(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr450;
  r1 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  zn15CProfileManager13StartProfileEPKc(i7);
  if (r1 !== 0) {
    r0 = heapClassInst.heap32[fp + numDefine2];
    if (r0 !== 0) {
      r2 = heapClassInst.heap32[fp];
      r3 = heapClassInst.heap32[fp + numDefine3];
      r4 = heapClassInst.heap32[fp + numDefine4];
      r5 = heapClassInst.heap32[fp + numDefine5];
      r6 = heapClassInst.heap32[fp + numDefine6];
      r7 = heapClassInst.heap32[fp + numDefine7];
      r8 = heapClassInst.heap32[fp + numDefine8];
      r9 = heapClassInst.heap32[fp + numDefine9];
      r10 = r2 >> numDefine2;
      r11 = heapClassInst.heap32[r10];
      r11 = r11 >> numDefine2;
      r11 = heapClassInst.heap32[r11 + numDefine8];
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r0;
      heapClassInst.heap32[g0 + numDefine3] = r3;
      heapClassInst.heap32[g0 + numDefine4] = r4;
      heapClassInst.heap32[g0 + numDefine5] = r5;
      heapClassInst.heap32[g0 + numDefine6] = r6;
      heapClassInst.heap32[g0 + numDefine7] = r7;
      heapClassInst.heap32[g0 + numDefine8] = r8;
      heapClassInst.heap32[g0 + numDefine9] = r9;
      functionTable[r11 >> numDefine2](i7);
      r11 = heapClassInst.heap32[r10];
      r11 = r11 >> numDefine2;
      r11 = heapClassInst.heap32[r11 + numDefine9];
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r0;
      heapClassInst.heap32[g0 + numDefine3] = r3;
      heapClassInst.heap32[g0 + numDefine4] = r4;
      heapClassInst.heap32[g0 + numDefine5] = r5;
      heapClassInst.heap32[g0 + numDefine6] = r6;
      heapClassInst.heap32[g0 + numDefine7] = r7;
      heapClassInst.heap32[g0 + numDefine8] = r8;
      heapClassInst.heap32[g0 + numDefine9] = r9;
      functionTable[r11 >> numDefine2](i7);
      r10 = heapClassInst.heap32[r10];
      r10 = r10 >> numDefine2;
      r10 = heapClassInst.heap32[r10 + numDefine7];
      heapClassInst.heap32[g0] = r2;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = r0;
      heapClassInst.heap32[g0 + numDefine3] = r3;
      heapClassInst.heap32[g0 + numDefine4] = r4;
      heapClassInst.heap32[g0 + numDefine5] = r5;
      heapClassInst.heap32[g0 + numDefine6] = r6;
      heapClassInst.heap32[g0 + numDefine7] = r7;
      heapClassInst.heap32[g0 + numDefine8] = r8;
      heapClassInst.heap32[g0 + numDefine9] = r9;
      r0 = zn15CProfileManager11CurrentNodeE;
      r0 = r0 >> numDefine2;
      functionTable[r10 >> numDefine2](i7);
      r1 = heapClassInst.heap32[r0];
      r2 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r2 + numDefine4];
      r3 = (r3 + -1) | 0;
      heapClassInst.heap32[r2 + numDefine4] = r3;
      repeat5: do {
        if (!(r3 !== 0)) {
          r3 = heapClassInst.heap32[r2 + 1];
          if (r3 !== 0) {
            r1 = sp + numDefineNeg8;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = 0;
            r3 = zl13gProfileClock2E0;
            getTimeOfDay(i7);
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r3 = r3 >> numDefine2;
            r1 = r1 >> numDefine2;
            r4 = heapClassInst.heap32[fp + numDefineNeg2];
            r5 = heapClassInst.heap32[r3];
            r4 = (r4 - r5) | 0;
            r1 = heapClassInst.heap32[r1 + 1];
            r3 = heapClassInst.heap32[r3 + 1];
            r1 = (r1 - r3) | 0;
            r3 = (r4 * numDefineN6) | 0;
            r1 = (r1 + r3) | 0;
            r3 = heapClassInst.heap32[r2 + numDefine3];
            r1 = (r1 - r3) | 0;
            f0 = uint(r1);
            f1 = numDefine1000;
            f2 = heapClassInst.heapFloat[r2 + numDefine2];
            f0 = f0 / f1;
            f0 = f2 + f0;
            heapClassInst.heapFloat[r2 + numDefine2] = f0;
            r1 = heapClassInst.heap32[r2 + numDefine4];
            if (r1 !== 0) {
              break repeat5;
            } else {
              r1 = heapClassInst.heap32[r0];
            }
          }
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine5];
          heapClassInst.heap32[r0] = r1;
        }
      } while (false);
      f0 = 0;
      commonVariable.fg0 = f0;
      return;
    } else {
      r0 = twoEStr753;
      r1 = twoEStr652;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine1186;
      assertNew(i7);
    }
  } else {
    r1 = twoEStr551;
    r0 = twoEStr652;
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = numDefine1185;
    assertNew(i7);
  }
}

function zn35btSFriendly(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg504;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[fp + numDefine2];
  r4 = heapClassInst.heap32[fp + numDefine7];
  r5 = heapClassInst.heap32[r1 + numDefine2];
  r6 = 0;
  repeat1: while (true) {
    if (r6 < r5) {
      r7 = (r6 * numDefine34) | 0;
      r8 = heapClassInst.heap32[r1 + numDefine4];
      r7 = r7 << numDefine2;
      r7 = (r8 + r7) | 0;
      r7 = r7 >> numDefine2;
      r8 = heapClassInst.heap32[r7 + numDefine28];
      if (r8 !== 0) {
        r8 = r8 >> numDefine2;
        heapClassInst.heap32[r8 + numDefine28] = heapClassInst.heap32[r7 + numDefine21];
        r9 = heapClassInst.heapU8[r4 + numDefine60];
        r9 = r9 & numDefine8;
        if (!(r9 === 0)) {
          r9 = heapClassInst.heap32[r7 + numDefine25];
          r10 = heapClassInst.heap32[r1 + numDefine14];
          r9 = (r9 * numDefine136) | 0;
          r9 = (r10 + r9) | 0;
          r9 = r9 >> numDefine2;
          heapClassInst.heap32[r8 + numDefine30] = heapClassInst.heap32[r9 + numDefine21];
          r7 = heapClassInst.heap32[r7 + numDefine25];
          r9 = heapClassInst.heap32[r1 + numDefine14];
          r7 = (r7 * numDefine136) | 0;
          r7 = (r7 + r9) | 0;
          r7 = r7 >> numDefine2;
          heapClassInst.heap32[r8 + numDefine31] = heapClassInst.heap32[r7 + numDefine55];
        }
        r6 = (r6 + 1) | 0;
        continue repeat1;
      } else {
        label = numDefine2;
        break repeat1;
      }
    } else {
      label = numDefine7;
      break repeat1;
    }
  }
  switch (label) {
    case numDefine7:
      r5 = heapClassInst.heap32[r1 + numDefine7];
      repeat10: do {
        if (!(r5 < 1)) {
          r6 = 0;
          repeat12: while (true) {
            r7 = (r6 * numDefine34) | 0;
            r8 = heapClassInst.heap32[r1 + numDefine9];
            r7 = r7 << numDefine2;
            r7 = (r8 + r7) | 0;
            r7 = r7 >> numDefine2;
            r8 = heapClassInst.heap32[r7 + numDefine28];
            r8 = r8 >> numDefine2;
            f0 = heapClassInst.heapFloat[r8 + numDefine7];
            f1 = heapClassInst.heapFloat[r7 + numDefine21];
            r6 = (r6 + 1) | 0;
            f0 = f1 + f0;
            heapClassInst.heapFloat[r8 + numDefine7] = f0;
            if (r5 !== r6) {
              continue repeat12;
            } else {
              break repeat10;
            }
          }
        }
      } while (false);
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4 + numDefine11];
      repeat15: do {
        if (r5 !== 0) {
          if (!(r3 < 1)) {
            label = numDefine13;
            repeat17: while (true) {
              r5 = r2 >> numDefine2;
              r5 = heapClassInst.heap32[r5];
              r6 = heapClassInst.heapU8[r5 + numDefine232];
              r6 = r6 & numDefine2;
              if (!(r6 === 0)) {
                if (!(r5 === 0)) {
                  r6 = r5 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r6 + numDefine84];
                  f1 = 0;
                  if (!(f0 === f1)) {
                    f0 = heapClassInst.heapFloat[r4 + numDefine3];
                    f1 = heapClassInst.heapFloat[r6 + numDefine78];
                    f2 = heapClassInst.heapFloat[r6 + numDefine128];
                    f3 = heapClassInst.heapFloat[r6 + numDefine77];
                    f4 = heapClassInst.heapFloat[r6 + numDefine127];
                    f5 = heapClassInst.heapFloat[r6 + numDefine76];
                    f6 = heapClassInst.heapFloat[r6 + numDefine126];
                    f5 = f5 + f6;
                    f3 = f3 + f4;
                    heapClassInst.heapFloat[r6 + numDefine76] = f5;
                    f1 = f1 + f2;
                    heapClassInst.heapFloat[r6 + numDefine77] = f3;
                    heapClassInst.heapFloat[r6 + numDefine78] = f1;
                    heapClassInst.heap32[r6 + numDefine79] = 0;
                    f1 = heapClassInst.heapFloat[r6 + numDefine82];
                    f2 = heapClassInst.heapFloat[r6 + numDefine132];
                    f3 = heapClassInst.heapFloat[r6 + numDefine81];
                    f4 = heapClassInst.heapFloat[r6 + numDefine131];
                    f5 = heapClassInst.heapFloat[r6 + numDefine80];
                    f6 = heapClassInst.heapFloat[r6 + numDefine130];
                    f5 = f5 + f6;
                    f3 = f3 + f4;
                    heapClassInst.heapFloat[r6 + numDefine80] = f5;
                    f1 = f1 + f2;
                    heapClassInst.heapFloat[r6 + numDefine81] = f3;
                    heapClassInst.heapFloat[r6 + numDefine82] = f1;
                    heapClassInst.heap32[r6 + numDefine83] = 0;
                    f1 = heapClassInst.heapFloat[r6 + numDefine142];
                    f2 = heapClassInst.heapFloat[r6 + numDefine143];
                    f3 = heapClassInst.heapFloat[r6 + numDefine144];
                    r7 = sp + numDefineNeg64;
                    r8 = (r5 + numDefine4) | 0;
                    r5 = (r5 + numDefine584) | 0;
                    heapClassInst.heap32[g0] = r8;
                    heapClassInst.heapFloat[g0 + 1] = f1;
                    heapClassInst.heapFloat[g0 + numDefine2] = f2;
                    heapClassInst.heapFloat[g0 + numDefine3] = f3;
                    heapClassInst.heap32[g0 + numDefine4] = r5;
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = r7;
                    zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                    r5 = r7 >> numDefine2;
                    heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[fp + numDefineNeg16];
                    heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r5 + 1];
                    heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r5 + numDefine2];
                    heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r5 + numDefine3];
                    heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r5 + numDefine4];
                    heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r5 + numDefine5];
                    heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r5 + numDefine6];
                    heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r5 + numDefine7];
                    heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r5 + numDefine8];
                    heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r5 + numDefine9];
                    heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r5 + numDefine10];
                    heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r5 + numDefine11];
                    heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r5 + numDefine12];
                    heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r5 + numDefine13];
                    heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r5 + numDefine14];
                    heapClassInst.heap32[r6 + numDefine16] = heapClassInst.heap32[r5 + numDefine15];
                  }
                }
              }
              r3 = (r3 + -1) | 0;
              r2 = (r2 + numDefine4) | 0;
              if (r3 === 0) {
                break repeat15;
              } else {
                continue repeat17;
              }
            }
          }
        } else {
          if (!(r3 < 1)) {
            label = numDefine18;
            repeat25: while (true) {
              r4 = r2 >> numDefine2;
              r4 = heapClassInst.heap32[r4];
              r5 = heapClassInst.heapU8[r4 + numDefine232];
              r5 = r5 & numDefine2;
              if (!(r5 === 0)) {
                if (!(r4 === 0)) {
                  r4 = r4 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r4 + numDefine84];
                  f1 = 0;
                  if (!(f0 === f1)) {
                    f0 = heapClassInst.heapFloat[r4 + numDefine78];
                    f1 = heapClassInst.heapFloat[r4 + numDefine128];
                    f2 = heapClassInst.heapFloat[r4 + numDefine77];
                    f3 = heapClassInst.heapFloat[r4 + numDefine127];
                    f4 = heapClassInst.heapFloat[r4 + numDefine76];
                    f5 = heapClassInst.heapFloat[r4 + numDefine126];
                    f4 = f4 + f5;
                    f2 = f2 + f3;
                    heapClassInst.heapFloat[r4 + numDefine76] = f4;
                    f0 = f0 + f1;
                    heapClassInst.heapFloat[r4 + numDefine77] = f2;
                    heapClassInst.heapFloat[r4 + numDefine78] = f0;
                    heapClassInst.heap32[r4 + numDefine79] = 0;
                    f0 = heapClassInst.heapFloat[r4 + numDefine82];
                    f1 = heapClassInst.heapFloat[r4 + numDefine132];
                    f2 = heapClassInst.heapFloat[r4 + numDefine81];
                    f3 = heapClassInst.heapFloat[r4 + numDefine131];
                    f4 = heapClassInst.heapFloat[r4 + numDefine80];
                    f5 = heapClassInst.heapFloat[r4 + numDefine130];
                    f4 = f4 + f5;
                    f2 = f2 + f3;
                    heapClassInst.heapFloat[r4 + numDefine80] = f4;
                    f0 = f0 + f1;
                    heapClassInst.heapFloat[r4 + numDefine81] = f2;
                    heapClassInst.heapFloat[r4 + numDefine82] = f0;
                    heapClassInst.heap32[r4 + numDefine83] = 0;
                  }
                }
              }
              r3 = (r3 + -1) | 0;
              r2 = (r2 + numDefine4) | 0;
              if (r3 !== 0) {
                continue repeat25;
              } else {
                break repeat15;
              }
            }
          }
        }
      } while (false);
      r2 = heapClassInst.heap32[r1 + numDefine2];
      repeat33: do {
        if (!(r2 > -1)) {
          r3 = heapClassInst.heap32[r1 + numDefine3];
          if (!(r3 > -1)) {
            r3 = heapClassInst.heap32[r1 + numDefine4];
            if (!(r3 === 0)) {
              r4 = heapClassInst.heapU8[r0 + numDefine20];
              if (!(r4 === 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
              }
              heapClassInst.heap32[r1 + numDefine4] = 0;
            }
            r3 = 1;
            heapClassInst.heap8[r0 + numDefine20] = r3;
            heapClassInst.heap32[r1 + numDefine4] = 0;
            heapClassInst.heap32[r1 + numDefine3] = 0;
          }
          r3 = (r2 * numDefine136) | 0;
          repeat44: while (true) {
            r4 = heapClassInst.heap32[r1 + numDefine4];
            r4 = (r4 + r3) | 0;
            r5 = sp + numDefineNeg472;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
            r2 = (r2 + 1) | 0;
            r3 = (r3 + numDefine136) | 0;
            memcpy(i7);
            if (r2 !== 0) {
              continue repeat44;
            } else {
              break repeat33;
            }
          }
        }
      } while (false);
      heapClassInst.heap32[r1 + numDefine2] = 0;
      r2 = heapClassInst.heap32[r1 + numDefine7];
      repeat47: do {
        if (!(r2 > -1)) {
          r3 = heapClassInst.heap32[r1 + numDefine8];
          if (!(r3 > -1)) {
            r3 = heapClassInst.heap32[r1 + numDefine9];
            if (!(r3 === 0)) {
              r4 = heapClassInst.heapU8[r0 + numDefine40];
              if (!(r4 === 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
              }
              heapClassInst.heap32[r1 + numDefine9] = 0;
            }
            r3 = 1;
            heapClassInst.heap8[r0 + numDefine40] = r3;
            heapClassInst.heap32[r1 + numDefine9] = 0;
            heapClassInst.heap32[r1 + numDefine8] = 0;
          }
          r3 = (r2 * numDefine136) | 0;
          repeat58: while (true) {
            r4 = heapClassInst.heap32[r1 + numDefine9];
            r4 = (r4 + r3) | 0;
            r5 = sp + numDefineNeg336;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
            r2 = (r2 + 1) | 0;
            r3 = (r3 + numDefine136) | 0;
            memcpy(i7);
            if (r2 !== 0) {
              continue repeat58;
            } else {
              break repeat47;
            }
          }
        }
      } while (false);
      heapClassInst.heap32[r1 + numDefine7] = 0;
      r2 = heapClassInst.heap32[r1 + numDefine12];
      repeat61: do {
        if (!(r2 > -1)) {
          r3 = heapClassInst.heap32[r1 + numDefine13];
          if (!(r3 > -1)) {
            r3 = heapClassInst.heap32[r1 + numDefine14];
            if (!(r3 === 0)) {
              r4 = heapClassInst.heapU8[r0 + numDefine60];
              if (!(r4 === 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
              }
              heapClassInst.heap32[r1 + numDefine14] = 0;
            }
            r3 = 1;
            heapClassInst.heap8[r0 + numDefine60] = r3;
            heapClassInst.heap32[r1 + numDefine14] = 0;
            heapClassInst.heap32[r1 + numDefine13] = 0;
          }
          r0 = (r2 * numDefine136) | 0;
          repeat72: while (true) {
            r3 = heapClassInst.heap32[r1 + numDefine14];
            r3 = (r3 + r0) | 0;
            r4 = sp + numDefineNeg200;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = numDefine136;
            r2 = (r2 + 1) | 0;
            r0 = (r0 + numDefine136) | 0;
            memcpy(i7);
            if (r2 !== 0) {
              continue repeat72;
            } else {
              break repeat61;
            }
          }
        }
      } while (false);
      heapClassInst.heap32[r1 + numDefine12] = 0;
      f0 = 0;
      commonVariable.fg0 = f0;
      return;
    case numDefine2:
      r0 = twoEStr955;
      r1 = twoEStr652;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine1129;
      assertNew(i7);
      break;
    default:
      break;
  }
}

function zn35btsConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let r25: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg584;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr1056;
  r1 = heapClassInst.heap32[fp + numDefine6];
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp + numDefine4];
  heapClassInst.heap32[fp + numDefineNeg133] = r0;
  r2 = 0;
  zn15CProfileManager13StartProfileEPKc(i7);
  r0 = (r2 - r0) | 0;
  repeat1: do {
    if (!(r1 === r0)) {
      r0 = heapClassInst.heap32[fp];
      r3 = heapClassInst.heap32[fp + 1];
      r4 = heapClassInst.heap32[fp + numDefine2];
      r5 = heapClassInst.heap32[fp + numDefine3];
      heapClassInst.heap32[fp + numDefineNeg132] = r5;
      r5 = heapClassInst.heap32[fp + numDefine5];
      heapClassInst.heap32[fp + numDefineNeg127] = r5;
      r5 = heapClassInst.heap32[fp + numDefine7];
      r6 = r5 >> numDefine2;
      r7 = heapClassInst.heap32[r6 + numDefine11];
      repeat3: do {
        if (r7 !== 0) {
          if (!(r4 < 1)) {
            label = numDefine4;
            repeat5: while (true) {
              r7 = r3 >> numDefine2;
              r7 = heapClassInst.heap32[r7];
              r8 = heapClassInst.heapU8[r7 + numDefine232];
              r8 = r8 & numDefine2;
              if (!(r8 === 0)) {
                if (!(r7 === 0)) {
                  r7 = r7 >> numDefine2;
                  heapClassInst.heap32[r7 + numDefine126] = 0;
                  heapClassInst.heap32[r7 + numDefine127] = 0;
                  heapClassInst.heap32[r7 + numDefine128] = 0;
                  heapClassInst.heap32[r7 + numDefine129] = 0;
                  heapClassInst.heap32[r7 + numDefine130] = 0;
                  heapClassInst.heap32[r7 + numDefine131] = 0;
                  heapClassInst.heap32[r7 + numDefine132] = 0;
                  heapClassInst.heap32[r7 + numDefine133] = 0;
                  heapClassInst.heap32[r7 + numDefine142] = 0;
                  heapClassInst.heap32[r7 + numDefine143] = 0;
                  heapClassInst.heap32[r7 + numDefine144] = 0;
                  heapClassInst.heap32[r7 + numDefine145] = 0;
                  heapClassInst.heap32[r7 + numDefine146] = 0;
                  heapClassInst.heap32[r7 + numDefine147] = 0;
                  heapClassInst.heap32[r7 + numDefine148] = 0;
                  heapClassInst.heap32[r7 + numDefine149] = 0;
                }
              }
              r4 = (r4 + -1) | 0;
              r3 = (r3 + numDefine4) | 0;
              if (r4 === 0) {
                break repeat3;
              } else {
                continue repeat5;
              }
            }
          }
        } else {
          if (!(r4 < 1)) {
            label = numDefine8;
            while (true) {
              r7 = r3 >> numDefine2;
              r7 = heapClassInst.heap32[r7];
              r8 = heapClassInst.heapU8[r7 + numDefine232];
              r8 = r8 & numDefine2;
              if (!(r8 === 0)) {
                if (!(r7 === 0)) {
                  r7 = r7 >> numDefine2;
                  heapClassInst.heap32[r7 + numDefine126] = 0;
                  heapClassInst.heap32[r7 + numDefine127] = 0;
                  heapClassInst.heap32[r7 + numDefine128] = 0;
                  heapClassInst.heap32[r7 + numDefine129] = 0;
                  heapClassInst.heap32[r7 + numDefine130] = 0;
                  heapClassInst.heap32[r7 + numDefine131] = 0;
                  heapClassInst.heap32[r7 + numDefine132] = 0;
                  heapClassInst.heap32[r7 + numDefine133] = 0;
                }
              }
              r4 = (r4 + -1) | 0;
              r3 = (r3 + numDefine4) | 0;
              if (r4 === 0) {
                break repeat3;
              }
            }
          }
        }
      } while (false);
      repeat19: do {
        if (r1 < 1) {
          r4 = r0 >> numDefine2;
          r3 = heapClassInst.heap32[r4 + numDefine27];
          repeat21: do {
            if (!(r3 > r1)) {
              if (!(r3 >= r1)) {
                r7 = heapClassInst.heap32[r4 + numDefine28];
                if (!(r7 >= r1)) {
                  if (r1 !== 0) {
                    r7 = gNumAlignedAllocs;
                    r7 = r7 >> numDefine2;
                    r8 = heapClassInst.heap32[r7];
                    r9 = r1 << numDefine3;
                    r8 = (r8 + 1) | 0;
                    r9 = r9 | numDefine3;
                    heapClassInst.heap32[r7] = r8;
                    r7 = (r9 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r7;
                    mallocNew(i7);
                    r7 = commonVariable.rg0;
                    if (r7 !== 0) {
                      r8 = (r7 + numDefine4) | 0;
                      r8 = (r2 - r8) | 0;
                      r8 = r8 & numDefine15;
                      r8 = (r7 + r8) | 0;
                      r9 = (r8 + numDefine4) | 0;
                      r8 = r8 >> numDefine2;
                      heapClassInst.heap32[r8] = r7;
                      r7 = r9;
                    }
                  } else {
                    r7 = 0;
                  }
                  r8 = (r0 + numDefine116) | 0;
                  if (r3 < 1) {
                    r2 = r8 >> numDefine2;
                    r9 = heapClassInst.heap32[r2];
                  } else {
                    repeat33: while (true) {
                      r9 = r8 >> numDefine2;
                      r9 = heapClassInst.heap32[r9];
                      r10 = r2 << numDefine3;
                      r11 = (r9 + r10) | 0;
                      r11 = r11 >> numDefine2;
                      r10 = (r7 + r10) | 0;
                      r12 = heapClassInst.heap32[r11 + 1];
                      r11 = heapClassInst.heap32[r11];
                      r10 = r10 >> numDefine2;
                      r2 = (r2 + 1) | 0;
                      heapClassInst.heap32[r10] = r11;
                      heapClassInst.heap32[r10 + 1] = r12;
                      if (!(r3 !== r2)) {
                        break repeat33;
                      }
                    }
                    r8 = (r0 + numDefine116) | 0;
                  }
                  if (!(r9 === 0)) {
                    r2 = heapClassInst.heapU8[r0 + numDefine120];
                    if (!(r2 === 0)) {
                      r2 = gNumAlignedFree;
                      r2 = r2 >> numDefine2;
                      r10 = heapClassInst.heap32[r2];
                      r10 = (r10 + 1) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r2] = r10;
                      r2 = heapClassInst.heap32[r9 + -1];
                      heapClassInst.heap32[g0] = r2;
                      free(i7);
                    }
                    r2 = r8 >> numDefine2;
                    heapClassInst.heap32[r2] = 0;
                  }
                  r2 = 1;
                  r8 = r8 >> numDefine2;
                  heapClassInst.heap8[r0 + numDefine120] = r2;
                  heapClassInst.heap32[r8] = r7;
                  heapClassInst.heap32[r4 + numDefine28] = r1;
                  if (r3 >= r1) {
                    break repeat21;
                  }
                }
                while (true) {
                  r2 = r3 << numDefine3;
                  r7 = heapClassInst.heap32[r4 + numDefine29];
                  r2 = (r7 + r2) | 0;
                  r2 = r2 >> numDefine2;
                  r3 = (r3 + 1) | 0;
                  heapClassInst.heap32[r2] = 0;
                  heapClassInst.heap32[r2 + 1] = 0;
                  if (!(r1 !== r3)) {
                    break repeat21;
                  }
                }
              }
            }
          } while (false);
          r3 = 0;
          heapClassInst.heap32[r4 + numDefine27] = r1;
        } else {
          r2 = 0;
          repeat47: while (true) {
            r3 = r2 << numDefine2;
            r4 = heapClassInst.heap32[fp + numDefineNeg127];
            r3 = (r4 + r3) | 0;
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
            r4 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine2];
            r2 = (r2 + 1) | 0;
            heapClassInst.heap32[g0] = r3;
            functionTable[r4 >> numDefine2](i7);
            if (r1 === r2) {
              break repeat47;
            }
          }
          r2 = r0 >> numDefine2;
          r3 = heapClassInst.heap32[r2 + numDefine27];
          repeat50: do {
            if (!(r3 > r1)) {
              if (!(r3 >= r1)) {
                r4 = heapClassInst.heap32[r2 + numDefine28];
                if (!(r4 >= r1)) {
                  if (r1 !== 0) {
                    r4 = gNumAlignedAllocs;
                    r4 = r4 >> numDefine2;
                    r7 = heapClassInst.heap32[r4];
                    r8 = r1 << numDefine3;
                    r7 = (r7 + 1) | 0;
                    r8 = r8 | numDefine3;
                    heapClassInst.heap32[r4] = r7;
                    r4 = (r8 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r4;
                    mallocNew(i7);
                    r4 = commonVariable.rg0;
                    if (r4 !== 0) {
                      r7 = 0;
                      r8 = (r4 + numDefine4) | 0;
                      r7 = (r7 - r8) | 0;
                      r7 = r7 & numDefine15;
                      r7 = (r4 + r7) | 0;
                      r8 = (r7 + numDefine4) | 0;
                      r7 = r7 >> numDefine2;
                      heapClassInst.heap32[r7] = r4;
                      r4 = r8;
                    }
                  } else {
                    r4 = 0;
                  }
                  r7 = (r0 + numDefine116) | 0;
                  if (r3 < 1) {
                    r8 = r7 >> numDefine2;
                    r9 = heapClassInst.heap32[r8];
                  } else {
                    r8 = 0;
                    repeat63: while (true) {
                      r9 = r7 >> numDefine2;
                      r9 = heapClassInst.heap32[r9];
                      r10 = r8 << numDefine3;
                      r11 = (r9 + r10) | 0;
                      r11 = r11 >> numDefine2;
                      r10 = (r4 + r10) | 0;
                      r12 = heapClassInst.heap32[r11 + 1];
                      r11 = heapClassInst.heap32[r11];
                      r10 = r10 >> numDefine2;
                      r8 = (r8 + 1) | 0;
                      heapClassInst.heap32[r10] = r11;
                      heapClassInst.heap32[r10 + 1] = r12;
                      if (!(r3 !== r8)) {
                        break repeat63;
                      }
                    }
                    r7 = (r0 + numDefine116) | 0;
                  }
                  if (!(r9 === 0)) {
                    r8 = heapClassInst.heapU8[r0 + numDefine120];
                    if (!(r8 === 0)) {
                      r8 = gNumAlignedFree;
                      r8 = r8 >> numDefine2;
                      r10 = heapClassInst.heap32[r8];
                      r10 = (r10 + 1) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r8] = r10;
                      r8 = heapClassInst.heap32[r9 + -1];
                      heapClassInst.heap32[g0] = r8;
                      free(i7);
                    }
                    r8 = r7 >> numDefine2;
                    heapClassInst.heap32[r8] = 0;
                  }
                  r8 = 1;
                  r7 = r7 >> numDefine2;
                  heapClassInst.heap8[r0 + numDefine120] = r8;
                  heapClassInst.heap32[r7] = r4;
                  heapClassInst.heap32[r2 + numDefine28] = r1;
                  if (r3 >= r1) {
                    break repeat50;
                  }
                }
                while (true) {
                  r4 = r3 << numDefine3;
                  r7 = heapClassInst.heap32[r2 + numDefine29];
                  r4 = (r7 + r4) | 0;
                  r4 = r4 >> numDefine2;
                  r3 = (r3 + 1) | 0;
                  heapClassInst.heap32[r4] = 0;
                  heapClassInst.heap32[r4 + 1] = 0;
                  if (!(r1 !== r3)) {
                    break repeat50;
                  }
                }
              }
            }
          } while (false);
          heapClassInst.heap32[r2 + numDefine27] = r1;
          if (r1 > 0) {
            r4 = 0;
            r7 = heapClassInst.heap32[fp + numDefineNeg127];
            r8 = r1;
            r3 = r4;
            while (true) {
              r9 = r7 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = r9 >> numDefine2;
              r10 = heapClassInst.heap32[r10];
              r10 = r10 >> numDefine2;
              r10 = heapClassInst.heap32[r10 + numDefine4];
              r11 = heapClassInst.heap32[r2 + numDefine29];
              r11 = (r11 + r4) | 0;
              heapClassInst.heap32[g0] = r9;
              heapClassInst.heap32[g0 + 1] = r11;
              functionTable[r10 >> numDefine2](i7);
              r9 = r11 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r8 = (r8 + -1) | 0;
              r3 = (r9 + r3) | 0;
              r4 = (r4 + numDefine8) | 0;
              r7 = (r7 + numDefine4) | 0;
              if (!(r8 !== 0)) {
                break repeat19;
              }
            }
          } else {
            r3 = 0;
          }
        }
      } while (false);
      r2 = r0 >> numDefine2;
      r4 = heapClassInst.heap32[r2 + numDefine7];
      repeat82: do {
        if (!(r4 > r3)) {
          if (!(r4 >= r3)) {
            r7 = heapClassInst.heap32[r2 + numDefine8];
            if (!(r7 >= r3)) {
              if (r3 !== 0) {
                r7 = gNumAlignedAllocs;
                r7 = r7 >> numDefine2;
                r8 = heapClassInst.heap32[r7];
                r9 = (r3 * numDefine136) | 0;
                r8 = (r8 + 1) | 0;
                r9 = r9 | numDefine3;
                heapClassInst.heap32[r7] = r8;
                r7 = (r9 + numDefine16) | 0;
                heapClassInst.heap32[g0] = r7;
                mallocNew(i7);
                r7 = commonVariable.rg0;
                if (r7 !== 0) {
                  r8 = 0;
                  r9 = (r7 + numDefine4) | 0;
                  r8 = (r8 - r9) | 0;
                  r8 = r8 & numDefine15;
                  r8 = (r7 + r8) | 0;
                  r9 = (r8 + numDefine4) | 0;
                  r8 = r8 >> numDefine2;
                  heapClassInst.heap32[r8] = r7;
                  r7 = r9;
                }
              } else {
                r7 = 0;
              }
              r8 = (r0 + numDefine36) | 0;
              if (r4 < 1) {
                r9 = r8 >> numDefine2;
                r11 = heapClassInst.heap32[r9];
              } else {
                r9 = 0;
                r10 = r4;
                repeat95: while (true) {
                  r11 = r8 >> numDefine2;
                  r11 = heapClassInst.heap32[r11];
                  r12 = (r7 + r9) | 0;
                  r13 = (r11 + r9) | 0;
                  heapClassInst.heap32[g0] = r12;
                  heapClassInst.heap32[g0 + 1] = r13;
                  heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                  r10 = (r10 + -1) | 0;
                  r9 = (r9 + numDefine136) | 0;
                  memcpy(i7);
                  if (!(r10 !== 0)) {
                    break repeat95;
                  }
                }
                r8 = (r0 + numDefine36) | 0;
              }
              if (!(r11 === 0)) {
                r9 = heapClassInst.heapU8[r0 + numDefine40];
                if (!(r9 === 0)) {
                  r9 = gNumAlignedFree;
                  r9 = r9 >> numDefine2;
                  r10 = heapClassInst.heap32[r9];
                  r10 = (r10 + 1) | 0;
                  r11 = r11 >> numDefine2;
                  heapClassInst.heap32[r9] = r10;
                  r9 = heapClassInst.heap32[r11 + -1];
                  heapClassInst.heap32[g0] = r9;
                  free(i7);
                }
                r9 = r8 >> numDefine2;
                heapClassInst.heap32[r9] = 0;
              }
              r9 = 1;
              r8 = r8 >> numDefine2;
              heapClassInst.heap8[r0 + numDefine40] = r9;
              heapClassInst.heap32[r8] = r7;
              heapClassInst.heap32[r2 + numDefine8] = r3;
              if (r4 >= r3) {
                break repeat82;
              }
            }
            r7 = (r3 - r4) | 0;
            r4 = (r4 * numDefine136) | 0;
            while (true) {
              r8 = heapClassInst.heap32[r2 + numDefine9];
              r8 = (r8 + r4) | 0;
              r9 = sp + numDefineNeg448;
              heapClassInst.heap32[g0] = r8;
              heapClassInst.heap32[g0 + 1] = r9;
              heapClassInst.heap32[g0 + numDefine2] = numDefine136;
              r7 = (r7 + -1) | 0;
              r4 = (r4 + numDefine136) | 0;
              memcpy(i7);
              if (!(r7 !== 0)) {
                break repeat82;
              }
            }
          }
        }
      } while (false);
      r4 = 0;
      heapClassInst.heap32[r2 + numDefine7] = r3;
      r7 = r4;
      repeat109: while (true) {
        if (r4 < r1) {
          r8 = heapClassInst.heap32[r2 + numDefine29];
          r9 = r4 << numDefine3;
          r10 = (r8 + r9) | 0;
          r10 = r10 >> numDefine2;
          r10 = heapClassInst.heap32[r10];
          if (r10 !== 0) {
            if (r7 < r3) {
              r11 = r4 << 1;
              r12 = r4 << numDefine2;
              r13 = heapClassInst.heap32[fp + numDefineNeg127];
              r12 = (r13 + r12) | 0;
              r12 = r12 >> numDefine2;
              r13 = heapClassInst.heap32[r12];
              r14 = r13 >> numDefine2;
              r15 = heapClassInst.heap32[r2 + numDefine9];
              r16 = heapClassInst.heap32[r14 + numDefine5];
              r17 = heapClassInst.heap32[r14 + numDefine6];
              if (!(r10 < 1)) {
                r10 = (r7 * numDefine136) | 0;
                r10 = (r15 + r10) | 0;
                r18 = 0;
                r19 = r18;
                repeat117: while (true) {
                  r20 = (r19 * numDefine34) | 0;
                  r21 = numDefine136;
                  r22 = r18;
                  repeat119: while (true) {
                    r21 = (r21 + -1) | 0;
                    r23 = (r22 + 1) | 0;
                    r22 = (r10 + r22) | 0;
                    r24 = (r19 * numDefine136) | 0;
                    heapClassInst.heap8[r22 + r24] = r18;
                    r22 = r23;
                    if (!(r21 !== 0)) {
                      break repeat119;
                    }
                  }
                  r21 = r20 << numDefine2;
                  r22 = r20 << numDefine2;
                  r21 = (r10 + r21) | 0;
                  r23 = r20 << numDefine2;
                  r22 = (r10 + r22) | 0;
                  r21 = r21 >> numDefine2;
                  r24 = r20 << numDefine2;
                  r23 = (r10 + r23) | 0;
                  r22 = r22 >> numDefine2;
                  heapClassInst.heap32[r21 + numDefine31] = numDefineNeg88609;
                  r21 = r20 << numDefine2;
                  r24 = (r10 + r24) | 0;
                  r23 = r23 >> numDefine2;
                  heapClassInst.heap32[r22 + numDefine32] = numDefine95039;
                  r20 = r20 << numDefine2;
                  r21 = (r10 + r21) | 0;
                  r22 = r24 >> numDefine2;
                  heapClassInst.heap32[r23 + numDefine21] = 0;
                  r20 = (r10 + r20) | 0;
                  r23 = r11 << numDefine2;
                  r21 = r21 >> numDefine2;
                  heapClassInst.heap32[r22 + numDefine20] = 0;
                  r22 = (r8 + r23) | 0;
                  r19 = (r19 + 1) | 0;
                  r20 = r20 >> numDefine2;
                  heapClassInst.heap32[r21 + numDefine26] = r16;
                  r21 = r22 >> numDefine2;
                  heapClassInst.heap32[r20 + numDefine27] = r17;
                  r20 = heapClassInst.heap32[r21];
                  if (!(r20 > r19)) {
                    break repeat117;
                  }
                }
              }
              r10 = r16 >> numDefine2;
              heapClassInst.heap32[r10 + numDefine126] = 0;
              heapClassInst.heap32[r10 + numDefine127] = 0;
              heapClassInst.heap32[r10 + numDefine128] = 0;
              heapClassInst.heap32[r10 + numDefine129] = 0;
              heapClassInst.heap32[r10 + numDefine130] = 0;
              heapClassInst.heap32[r10 + numDefine131] = 0;
              heapClassInst.heap32[r10 + numDefine132] = 0;
              heapClassInst.heap32[r10 + numDefine133] = 0;
              r16 = r17 >> numDefine2;
              heapClassInst.heap32[r16 + numDefine126] = 0;
              heapClassInst.heap32[r16 + numDefine127] = 0;
              heapClassInst.heap32[r16 + numDefine128] = 0;
              heapClassInst.heap32[r16 + numDefine129] = 0;
              heapClassInst.heap32[r16 + numDefine130] = 0;
              heapClassInst.heap32[r16 + numDefine131] = 0;
              heapClassInst.heap32[r16 + numDefine132] = 0;
              heapClassInst.heap32[r16 + numDefine133] = 0;
              f0 = 1;
              f1 = heapClassInst.heapFloat[r6 + numDefine3];
              r17 = sp + numDefineNeg504;
              f1 = f0 / f1;
              r18 = (r7 * numDefine136) | 0;
              r15 = (r15 + r18) | 0;
              r18 = r17 >> numDefine2;
              heapClassInst.heapFloat[fp + numDefineNeg126] = f1;
              r19 = (r15 + numDefine16) | 0;
              heapClassInst.heap32[r18 + 1] = heapClassInst.heap32[r6 + numDefine8];
              heapClassInst.heap32[r18 + numDefine2] = r19;
              heapClassInst.heap32[r18 + numDefine3] = r15;
              r19 = (r15 + numDefine32) | 0;
              heapClassInst.heap32[r18 + numDefine4] = 0;
              heapClassInst.heap32[r18 + numDefine5] = r19;
              r19 = (r15 + numDefine116) | 0;
              heapClassInst.heap32[r18 + numDefine6] = numDefine34;
              r20 = r15 >> numDefine2;
              heapClassInst.heap32[r18 + numDefine7] = r19;
              heapClassInst.heap32[r20 + numDefine30] = heapClassInst.heap32[r6 + numDefine10];
              r19 = (r15 + numDefine120) | 0;
              heapClassInst.heap32[r18 + numDefine13] = heapClassInst.heap32[r6 + 1];
              r20 = (r15 + numDefine124) | 0;
              heapClassInst.heap32[r18 + numDefine8] = r19;
              r19 = (r15 + numDefine128) | 0;
              heapClassInst.heap32[r18 + numDefine9] = r20;
              heapClassInst.heap32[r18 + numDefine10] = r19;
              r19 = heapClassInst.heap32[r6 + numDefine5];
              heapClassInst.heap32[r18 + numDefine12] = r19;
              r12 = heapClassInst.heap32[r12];
              r19 = r12 >> numDefine2;
              r19 = heapClassInst.heap32[r19];
              r19 = r19 >> numDefine2;
              r19 = heapClassInst.heap32[r19 + numDefine5];
              r11 = r11 << numDefine2;
              heapClassInst.heap32[g0] = r12;
              heapClassInst.heap32[g0 + 1] = r17;
              r8 = (r8 + r11) | 0;
              r8 = r8 >> numDefine2;
              functionTable[r19 >> numDefine2](i7);
              r11 = heapClassInst.heap32[r8];
              repeat123: do {
                if (!(r11 < 1)) {
                  r11 = 0;
                  while (true) {
                    r12 = (r11 * numDefine34) | 0;
                    r12 = r12 << numDefine2;
                    r12 = (r15 + r12) | 0;
                    r12 = r12 >> numDefine2;
                    heapClassInst.heap32[r12 + numDefine28] = r13;
                    r17 = heapClassInst.heap32[r14 + numDefine5];
                    r17 = r17 >> numDefine2;
                    f1 = heapClassInst.heapFloat[r12];
                    f2 = heapClassInst.heapFloat[r17 + numDefine64];
                    f3 = heapClassInst.heapFloat[r12 + 1];
                    f4 = heapClassInst.heapFloat[r17 + numDefine65];
                    f5 = heapClassInst.heapFloat[r17 + numDefine68];
                    f6 = heapClassInst.heapFloat[r17 + numDefine69];
                    f2 = f2 * f1;
                    f4 = f4 * f3;
                    f7 = heapClassInst.heapFloat[r12 + numDefine2];
                    f8 = heapClassInst.heapFloat[r17 + numDefine66];
                    f9 = heapClassInst.heapFloat[r17 + numDefine72];
                    f10 = heapClassInst.heapFloat[r17 + numDefine73];
                    f11 = heapClassInst.heapFloat[r17 + numDefine70];
                    f5 = f5 * f1;
                    f6 = f6 * f3;
                    f2 = f2 + f4;
                    f4 = f8 * f7;
                    f8 = heapClassInst.heapFloat[r17 + numDefine74];
                    f9 = f9 * f1;
                    f10 = f10 * f3;
                    f5 = f5 + f6;
                    f6 = f11 * f7;
                    f2 = f2 + f4;
                    f4 = heapClassInst.heapFloat[r17 + numDefine134];
                    f11 = heapClassInst.heapFloat[r17 + numDefine136];
                    f12 = heapClassInst.heapFloat[r17 + numDefine135];
                    f5 = f5 + f6;
                    f6 = f9 + f10;
                    f8 = f8 * f7;
                    f2 = f2 * f4;
                    f4 = f6 + f8;
                    f5 = f5 * f12;
                    heapClassInst.heapFloat[r12 + numDefine12] = f2;
                    f2 = f4 * f11;
                    heapClassInst.heapFloat[r12 + numDefine13] = f5;
                    heapClassInst.heapFloat[r12 + numDefine14] = f2;
                    heapClassInst.heap32[r12 + numDefine15] = 0;
                    r17 = heapClassInst.heap32[r14 + numDefine6];
                    r17 = r17 >> numDefine2;
                    f2 = heapClassInst.heapFloat[r12 + numDefine8];
                    f4 = heapClassInst.heapFloat[r17 + numDefine64];
                    f5 = heapClassInst.heapFloat[r12 + numDefine9];
                    f6 = heapClassInst.heapFloat[r17 + numDefine65];
                    f8 = heapClassInst.heapFloat[r17 + numDefine68];
                    f9 = heapClassInst.heapFloat[r17 + numDefine69];
                    f4 = f4 * f2;
                    f6 = f6 * f5;
                    f10 = heapClassInst.heapFloat[r12 + numDefine10];
                    f11 = heapClassInst.heapFloat[r17 + numDefine66];
                    f12 = heapClassInst.heapFloat[r17 + numDefine72];
                    f13 = heapClassInst.heapFloat[r17 + numDefine73];
                    f14 = heapClassInst.heapFloat[r17 + numDefine70];
                    f8 = f8 * f2;
                    f9 = f9 * f5;
                    f4 = f4 + f6;
                    f6 = f11 * f10;
                    f11 = heapClassInst.heapFloat[r17 + numDefine74];
                    f12 = f12 * f2;
                    f13 = f13 * f5;
                    f8 = f8 + f9;
                    f9 = f14 * f10;
                    f4 = f4 + f6;
                    f6 = heapClassInst.heapFloat[r17 + numDefine134];
                    f14 = heapClassInst.heapFloat[r17 + numDefine136];
                    f15 = heapClassInst.heapFloat[r17 + numDefine135];
                    f8 = f8 + f9;
                    f9 = f12 + f13;
                    f11 = f11 * f10;
                    f4 = f4 * f6;
                    f6 = f9 + f11;
                    f8 = f8 * f15;
                    heapClassInst.heapFloat[r12 + numDefine16] = f4;
                    f4 = f6 * f14;
                    heapClassInst.heapFloat[r12 + numDefine17] = f8;
                    heapClassInst.heapFloat[r12 + numDefine18] = f4;
                    heapClassInst.heap32[r12 + numDefine19] = 0;
                    f4 = heapClassInst.heapFloat[r10 + numDefine68];
                    f6 = heapClassInst.heapFloat[r10 + numDefine69];
                    f8 = heapClassInst.heapFloat[r10 + numDefine64];
                    f9 = heapClassInst.heapFloat[r10 + numDefine65];
                    f11 = heapClassInst.heapFloat[r10 + numDefine72];
                    f12 = heapClassInst.heapFloat[r10 + numDefine73];
                    f13 = heapClassInst.heapFloat[r10 + numDefine70];
                    f14 = heapClassInst.heapFloat[r10 + numDefine66];
                    f8 = f8 * f1;
                    f9 = f9 * f3;
                    f4 = f4 * f1;
                    f6 = f6 * f3;
                    f15 = heapClassInst.heapFloat[r10 + numDefine74];
                    f16 = heapClassInst.heapFloat[r16 + numDefine68];
                    f17 = heapClassInst.heapFloat[r16 + numDefine69];
                    f18 = heapClassInst.heapFloat[r16 + numDefine64];
                    f19 = heapClassInst.heapFloat[r16 + numDefine65];
                    f8 = f8 + f9;
                    f9 = f14 * f7;
                    f4 = f4 + f6;
                    f6 = f13 * f7;
                    f11 = f11 * f1;
                    f12 = f12 * f3;
                    f13 = heapClassInst.heapFloat[r10 + numDefine84];
                    f14 = heapClassInst.heapFloat[r12 + numDefine5];
                    f20 = heapClassInst.heapFloat[r12 + numDefine4];
                    f21 = heapClassInst.heapFloat[r16 + numDefine84];
                    f22 = heapClassInst.heapFloat[r12 + numDefine6];
                    f8 = f8 + f9;
                    f4 = f4 + f6;
                    f6 = f20 * f13;
                    f9 = f14 * f13;
                    f23 = heapClassInst.heapFloat[r16 + numDefine72];
                    f24 = heapClassInst.heapFloat[r16 + numDefine73];
                    f25 = heapClassInst.heapFloat[r16 + numDefine70];
                    f26 = heapClassInst.heapFloat[r16 + numDefine66];
                    f18 = f18 * f2;
                    f19 = f19 * f5;
                    f16 = f16 * f2;
                    f17 = f17 * f5;
                    f11 = f11 + f12;
                    f12 = f15 * f7;
                    f15 = heapClassInst.heapFloat[r16 + numDefine74];
                    f27 = f20 * f21;
                    f28 = f14 * f21;
                    f11 = f11 + f12;
                    f12 = f22 * f13;
                    f13 = f18 + f19;
                    f18 = f26 * f10;
                    f16 = f16 + f17;
                    f17 = f25 * f10;
                    f19 = f23 * f2;
                    f23 = f24 * f5;
                    f8 = f8 * f1;
                    f4 = f4 * f3;
                    f6 = f6 * f20;
                    f9 = f9 * f14;
                    f13 = f13 + f18;
                    f16 = f16 + f17;
                    f17 = f22 * f21;
                    f18 = f19 + f23;
                    f15 = f15 * f10;
                    f19 = f27 * f20;
                    f21 = f28 * f14;
                    f4 = f8 + f4;
                    f8 = f11 * f7;
                    f6 = f6 + f9;
                    f9 = f12 * f22;
                    f11 = f18 + f15;
                    f12 = f13 * f2;
                    f13 = f16 * f5;
                    f15 = f19 + f21;
                    f16 = f17 * f22;
                    f4 = f4 + f8;
                    f6 = f6 + f9;
                    f8 = f12 + f13;
                    f9 = f11 * f10;
                    f11 = f15 + f16;
                    f4 = f4 + f6;
                    f6 = f8 + f9;
                    f4 = f11 + f4;
                    f4 = f6 + f4;
                    f4 = f0 / f4;
                    heapClassInst.heapFloat[r12 + numDefine23] = f4;
                    f6 = heapClassInst.heapFloat[r10 + numDefine76];
                    f8 = heapClassInst.heapFloat[r10 + numDefine77];
                    f9 = heapClassInst.heapFloat[r10 + numDefine80];
                    f11 = heapClassInst.heapFloat[r10 + numDefine81];
                    f12 = heapClassInst.heapFloat[r16 + numDefine80];
                    f13 = heapClassInst.heapFloat[r16 + numDefine81];
                    f15 = heapClassInst.heapFloat[r16 + numDefine76];
                    f16 = heapClassInst.heapFloat[r16 + numDefine77];
                    f17 = heapClassInst.heapFloat[r10 + numDefine78];
                    f18 = heapClassInst.heapFloat[r10 + numDefine82];
                    f19 = heapClassInst.heapFloat[r16 + numDefine82];
                    f21 = heapClassInst.heapFloat[r16 + numDefine78];
                    f6 = f20 * f6;
                    f8 = f14 * f8;
                    f1 = f1 * f9;
                    f3 = f3 * f11;
                    f2 = f2 * f12;
                    f5 = f5 * f13;
                    f9 = f20 * f15;
                    f11 = f14 * f16;
                    f6 = f6 + f8;
                    f8 = f22 * f17;
                    f1 = f1 + f3;
                    f3 = f7 * f18;
                    f2 = f2 + f5;
                    f5 = f10 * f19;
                    f7 = f9 + f11;
                    f9 = f22 * f21;
                    f6 = f6 + f8;
                    f1 = f1 + f3;
                    f2 = f2 + f5;
                    f3 = f7 + f9;
                    f1 = f6 + f1;
                    f2 = f2 - f3;
                    f1 = f1 + f2;
                    f2 = heapClassInst.heapFloat[r18 + numDefine13];
                    f3 = 0;
                    f1 = f2 * f1;
                    f2 = heapClassInst.heapFloat[r12 + numDefine29];
                    f1 = f3 - f1;
                    f2 = f4 * f2;
                    f1 = f4 * f1;
                    f1 = f2 + f1;
                    r11 = (r11 + 1) | 0;
                    heapClassInst.heapFloat[r12 + numDefine29] = f1;
                    heapClassInst.heap32[r12 + numDefine21] = 0;
                    r12 = heapClassInst.heap32[r8];
                    if (!(r12 > r11)) {
                      break repeat123;
                    }
                  }
                }
              } while (false);
              r8 = heapClassInst.heap32[r2 + numDefine29];
              r8 = (r8 + r9) | 0;
              r8 = r8 >> numDefine2;
              r8 = heapClassInst.heap32[r8];
            } else {
              label = numDefine78;
              break repeat109;
            }
          } else {
            r8 = 0;
          }
          r7 = (r8 + r7) | 0;
          r4 = (r4 + 1) | 0;
        } else {
          label = numDefine90;
          break repeat109;
        }
      }
      switch (label) {
        case numDefine90:
          r1 = heapClassInst.heap32[fp + numDefineNeg133];
          repeat132: do {
            if (!(r1 < 1)) {
              while (true) {
                r1 = heapClassInst.heap32[fp + numDefineNeg132];
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1];
                heapClassInst.heap32[fp + numDefineNeg128] = r1;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg127] = r1;
                r3 = heapClassInst.heap32[r1 + numDefine277];
                r1 = heapClassInst.heap32[r1 + numDefine278];
                r4 = heapClassInst.heapU8[r3 + numDefine232];
                r4 = r4 & numDefine2;
                if (r4 !== 0) {
                  r4 = r3;
                } else {
                  r4 = 0;
                }
                r7 = heapClassInst.heapU8[r1 + numDefine232];
                r7 = r7 & numDefine2;
                if (r7 !== 0) {
                  r7 = r1;
                } else {
                  r7 = 0;
                }
                if (r4 === 0) {
                  label = numDefine99;
                } else {
                  r4 = r4 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r4 + numDefine84];
                  f1 = 0;
                  if (f0 !== f1) {
                    label = numDefine101;
                  } else {
                    label = numDefine99;
                  }
                }
                if (label === numDefine99) {
                  if (r7 === 0) {
                    label = numDefine216;
                  } else {
                    r4 = r7 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r4 + numDefine84];
                    f1 = 0;
                    if (f0 === f1) {
                      label = numDefine216;
                    } else {
                      label = numDefine101;
                    }
                  }
                }
                if (label === numDefine101) {
                  r4 = heapClassInst.heap32[fp + numDefineNeg128];
                  r7 = (r4 + numDefine4) | 0;
                  heapClassInst.heap32[fp + numDefineNeg129] = r7;
                  r7 = (r4 + numDefine152) | 0;
                  heapClassInst.heap32[fp + numDefineNeg130] = r7;
                  r4 = (r4 + numDefine168) | 0;
                  heapClassInst.heap32[fp + numDefineNeg131] = r4;
                  r4 = 0;
                  r7 = r4;
                  repeat150: while (true) {
                    r8 = heapClassInst.heap32[fp + numDefineNeg127];
                    r8 = heapClassInst.heap32[r8 + numDefine279];
                    if (r8 > r7) {
                      r8 = heapClassInst.heap32[fp + numDefineNeg128];
                      r8 = (r8 + r4) | 0;
                      r9 = r8 >> numDefine2;
                      f0 = heapClassInst.heapFloat[r9 + numDefine21];
                      r10 = heapClassInst.heap32[fp + numDefineNeg127];
                      f1 = heapClassInst.heapFloat[r10 + numDefine281];
                      repeat153: do {
                        if (!(f0 > f1)) {
                          r10 = heapClassInst.heap32[fp + numDefineNeg129];
                          r10 = (r10 + r4) | 0;
                          r11 = heapClassInst.heap32[fp + numDefineNeg131];
                          r11 = (r11 + r4) | 0;
                          r12 = heapClassInst.heap32[fp + numDefineNeg130];
                          r12 = (r12 + r4) | 0;
                          r13 = heapClassInst.heap32[r2 + numDefine3];
                          r14 = heapClassInst.heap32[r2 + numDefine2];
                          if (r13 === r14) {
                            r15 = 1;
                            r16 = r14 << 1;
                            r16 = r14 === 0 ? r15 : r16;
                            if (r13 >= r16) {
                              label = numDefine104;
                            } else {
                              if (r16 !== 0) {
                                r13 = gNumAlignedAllocs;
                                r13 = r13 >> numDefine2;
                                r17 = heapClassInst.heap32[r13];
                                r18 = (r16 * numDefine136) | 0;
                                r17 = (r17 + 1) | 0;
                                r18 = r18 | numDefine3;
                                heapClassInst.heap32[r13] = r17;
                                r13 = (r18 + numDefine16) | 0;
                                heapClassInst.heap32[g0] = r13;
                                mallocNew(i7);
                                r17 = commonVariable.rg0;
                                if (r17 !== 0) {
                                  r13 = 0;
                                  r18 = (r17 + numDefine4) | 0;
                                  r13 = (r13 - r18) | 0;
                                  r13 = r13 & numDefine15;
                                  r13 = (r17 + r13) | 0;
                                  r18 = (r13 + numDefine4) | 0;
                                  r13 = r13 >> numDefine2;
                                  heapClassInst.heap32[r13] = r17;
                                  r17 = r18;
                                }
                              } else {
                                r17 = 0;
                              }
                              if (r14 < 1) {
                                r19 = heapClassInst.heap32[r2 + numDefine4];
                              } else {
                                r13 = 0;
                                r18 = r14;
                                repeat166: while (true) {
                                  r19 = heapClassInst.heap32[r2 + numDefine4];
                                  r20 = (r17 + r13) | 0;
                                  r21 = (r19 + r13) | 0;
                                  heapClassInst.heap32[g0] = r20;
                                  heapClassInst.heap32[g0 + 1] = r21;
                                  heapClassInst.heap32[g0 + numDefine2] = numDefine136;
                                  r18 = (r18 + -1) | 0;
                                  r13 = (r13 + numDefine136) | 0;
                                  memcpy(i7);
                                  if (!(r18 !== 0)) {
                                    break repeat166;
                                  }
                                }
                              }
                              if (r19 !== 0) {
                                r13 = heapClassInst.heapU8[r0 + numDefine20];
                                if (r13 !== 0) {
                                  r13 = gNumAlignedFree;
                                  r13 = r13 >> numDefine2;
                                  r18 = heapClassInst.heap32[r13];
                                  r18 = (r18 + 1) | 0;
                                  r19 = r19 >> numDefine2;
                                  heapClassInst.heap32[r13] = r18;
                                  r13 = heapClassInst.heap32[r19 + -1];
                                  heapClassInst.heap32[g0] = r13;
                                  free(i7);
                                  r13 = heapClassInst.heap32[r2 + numDefine2];
                                } else {
                                  r13 = r14;
                                }
                                heapClassInst.heap32[r2 + numDefine4] = 0;
                              } else {
                                r13 = r14;
                              }
                              heapClassInst.heap8[r0 + numDefine20] = r15;
                              heapClassInst.heap32[r2 + numDefine4] = r17;
                              heapClassInst.heap32[r2 + numDefine3] = r16;
                              label = numDefine121;
                            }
                          } else {
                            label = numDefine104;
                          }
                          if (label === numDefine104) {
                            r13 = r14;
                          }
                          r13 = (r13 + 1) | 0;
                          heapClassInst.heap32[r2 + numDefine2] = r13;
                          r13 = heapClassInst.heapU8[r3 + numDefine232];
                          r15 = heapClassInst.heapU8[r1 + numDefine232];
                          r13 = r13 & numDefine2;
                          r16 = 0;
                          r15 = r15 & numDefine2;
                          r13 = r13 === 0 ? r16 : r3;
                          r17 = heapClassInst.heap32[r2 + numDefine4];
                          r15 = r15 === 0 ? r16 : r1;
                          if (r13 === 0) {
                            r18 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                            r19 = heapClassInst.heapU8[r18];
                            if (!(r19 !== 0)) {
                              r19 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                              r20 = r19 >> numDefine2;
                              heapClassInst.heap32[r20 + numDefine41] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine42] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine43] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine44] = 0;
                              heapClassInst.heap32[r20 + numDefine45] = 0;
                              heapClassInst.heap32[r20 + numDefine46] = numDefine44395;
                              heapClassInst.heap32[r20 + numDefine47] = 0;
                              heapClassInst.heap32[r20 + numDefine48] = 0;
                              heapClassInst.heap32[r20 + numDefine49] = 0;
                              heapClassInst.heap32[r20 + numDefine50] = 0;
                              heapClassInst.heap32[r20 + numDefine51] = 1;
                              heapClassInst.heap32[r20 + numDefine52] = -1;
                              heapClassInst.heap32[r20 + numDefine53] = -1;
                              heapClassInst.heap32[r20 + numDefine54] = 1;
                              heapClassInst.heap32[r20 + numDefine55] = 0;
                              heapClassInst.heap32[r20 + numDefine56] = numDefine64608;
                              heapClassInst.heap32[r20 + numDefine57] = 0;
                              heapClassInst.heap32[r20 + numDefine58] = 1;
                              heapClassInst.heap32[r20 + numDefine59] = 0;
                              heapClassInst.heap32[r20 + numDefine60] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine61] = 0;
                              heapClassInst.heap32[r20 + numDefine62] = 0;
                              heapClassInst.heap32[r20 + numDefine63] = 0;
                              heapClassInst.heap32[r20 + 1] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine2] = 0;
                              heapClassInst.heap32[r20 + numDefine3] = 0;
                              heapClassInst.heap32[r20 + numDefine4] = 0;
                              heapClassInst.heap32[r20 + numDefine5] = 0;
                              heapClassInst.heap32[r20 + numDefine6] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine7] = 0;
                              heapClassInst.heap32[r20 + numDefine8] = 0;
                              heapClassInst.heap32[r20 + numDefine9] = 0;
                              heapClassInst.heap32[r20 + numDefine10] = 0;
                              heapClassInst.heap32[r20 + numDefine11] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine12] = 0;
                              heapClassInst.heap32[r20 + numDefine13] = 0;
                              heapClassInst.heap32[r20 + numDefine14] = 0;
                              r21 = ztv11btRigidBody;
                              heapClassInst.heap32[r20 + numDefine15] = 0;
                              r21 = (r21 + numDefine8) | 0;
                              heapClassInst.heap32[r20 + numDefine16] = 0;
                              r22 = 1;
                              heapClassInst.heap32[r20] = r21;
                              heapClassInst.heap8[r19 + numDefine492] = r22;
                              heapClassInst.heap32[r20 + numDefine122] = 0;
                              heapClassInst.heap32[r20 + numDefine120] = 0;
                              r21 = sp + numDefineNeg280;
                              heapClassInst.heap32[r20 + numDefine121] = 0;
                              r20 = r21 >> numDefine2;
                              heapClassInst.heap32[fp + numDefineNeg70] = 0;
                              heapClassInst.heap32[r20 + 1] = 0;
                              heapClassInst.heap32[r20 + numDefine18] = 0;
                              heapClassInst.heap32[r20 + numDefine19] = 0;
                              heapClassInst.heap32[r20 + numDefine20] = 0;
                              heapClassInst.heap32[r20 + numDefine21] = 0;
                              heapClassInst.heap32[r20 + numDefine22] = 0;
                              heapClassInst.heap32[r20 + numDefine23] = 0;
                              heapClassInst.heap32[r20 + numDefine24] = 0;
                              heapClassInst.heap32[r20 + numDefine25] = numDefine64608;
                              heapClassInst.heap32[r20 + numDefine26] = 0;
                              heapClassInst.heap32[r20 + numDefine27] = numDefine97773;
                              heapClassInst.heap32[r20 + numDefine28] = numDefine53216;
                              heapClassInst.heap8[sp + numDefineNeg164] = r16;
                              heapClassInst.heap32[r20 + numDefine30] = numDefine93162;
                              heapClassInst.heap32[r20 + numDefine31] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine32] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine33] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine2] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine3] = 0;
                              heapClassInst.heap32[r20 + numDefine4] = 0;
                              heapClassInst.heap32[r20 + numDefine5] = 0;
                              heapClassInst.heap32[r20 + numDefine6] = 0;
                              heapClassInst.heap32[r20 + numDefine7] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine8] = 0;
                              heapClassInst.heap32[r20 + numDefine9] = 0;
                              heapClassInst.heap32[r20 + numDefine10] = 0;
                              heapClassInst.heap32[r20 + numDefine11] = 0;
                              heapClassInst.heap32[r20 + numDefine12] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine13] = 0;
                              heapClassInst.heap32[r20 + numDefine14] = 0;
                              heapClassInst.heap32[r20 + numDefine15] = 0;
                              heapClassInst.heap32[r20 + numDefine16] = 0;
                              heapClassInst.heap32[r20 + numDefine17] = 0;
                              heapClassInst.heap32[g0] = r19;
                              heapClassInst.heap32[g0 + 1] = r21;
                              zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                              heapClassInst.heap8[r18] = r22;
                            }
                            r18 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                            r19 = r18 >> numDefine2;
                            r20 = heapClassInst.heap32[r19 + numDefine51];
                            r20 = r20 | 1;
                            heapClassInst.heap32[r19 + numDefine51] = r20;
                            heapClassInst.heap32[r19 + numDefine84] = 0;
                            f0 = 0;
                            f1 = heapClassInst.heapFloat[r19 + numDefine95];
                            f2 = heapClassInst.heapFloat[r19 + numDefine94];
                            f3 = heapClassInst.heapFloat[r19 + numDefine93];
                            f3 = f3 * f0;
                            f2 = f2 * f0;
                            heapClassInst.heapFloat[r19 + numDefine89] = f3;
                            f1 = f1 * f0;
                            heapClassInst.heapFloat[r19 + numDefine90] = f2;
                            heapClassInst.heapFloat[r19 + numDefine91] = f1;
                            heapClassInst.heap32[r19 + numDefine92] = 0;
                            heapClassInst.heap32[r19 + numDefine97] = 0;
                            heapClassInst.heap32[r19 + numDefine98] = 0;
                            heapClassInst.heap32[r19 + numDefine99] = 0;
                            heapClassInst.heap32[r19 + numDefine100] = 0;
                            f1 = heapClassInst.heapFloat[r19 + numDefine87];
                            f2 = heapClassInst.heapFloat[r19 + numDefine86];
                            f3 = heapClassInst.heapFloat[r19 + numDefine85];
                            f3 = f3 * f0;
                            f2 = f2 * f0;
                            heapClassInst.heapFloat[r19 + numDefine138] = f3;
                            f0 = f1 * f0;
                            heapClassInst.heapFloat[r19 + numDefine139] = f2;
                            heapClassInst.heapFloat[r19 + numDefine140] = f0;
                            heapClassInst.heap32[r19 + numDefine141] = 0;
                          } else {
                            r18 = r13;
                          }
                          r19 = (r14 * numDefine136) | 0;
                          r17 = (r17 + r19) | 0;
                          r17 = r17 >> numDefine2;
                          heapClassInst.heap32[r17 + numDefine26] = r18;
                          if (r15 === 0) {
                            r18 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                            r19 = heapClassInst.heapU8[r18];
                            if (!(r19 !== 0)) {
                              r19 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                              r20 = r19 >> numDefine2;
                              heapClassInst.heap32[r20 + numDefine41] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine42] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine43] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine44] = 0;
                              heapClassInst.heap32[r20 + numDefine45] = 0;
                              heapClassInst.heap32[r20 + numDefine46] = numDefine44395;
                              heapClassInst.heap32[r20 + numDefine47] = 0;
                              heapClassInst.heap32[r20 + numDefine48] = 0;
                              heapClassInst.heap32[r20 + numDefine49] = 0;
                              heapClassInst.heap32[r20 + numDefine50] = 0;
                              heapClassInst.heap32[r20 + numDefine51] = 1;
                              heapClassInst.heap32[r20 + numDefine52] = -1;
                              heapClassInst.heap32[r20 + numDefine53] = -1;
                              heapClassInst.heap32[r20 + numDefine54] = 1;
                              heapClassInst.heap32[r20 + numDefine55] = 0;
                              heapClassInst.heap32[r20 + numDefine56] = numDefine64608;
                              heapClassInst.heap32[r20 + numDefine57] = 0;
                              heapClassInst.heap32[r20 + numDefine58] = 1;
                              heapClassInst.heap32[r20 + numDefine59] = 0;
                              heapClassInst.heap32[r20 + numDefine60] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine61] = 0;
                              heapClassInst.heap32[r20 + numDefine62] = 0;
                              heapClassInst.heap32[r20 + numDefine63] = 0;
                              heapClassInst.heap32[r20 + 1] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine2] = 0;
                              heapClassInst.heap32[r20 + numDefine3] = 0;
                              heapClassInst.heap32[r20 + numDefine4] = 0;
                              heapClassInst.heap32[r20 + numDefine5] = 0;
                              heapClassInst.heap32[r20 + numDefine6] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine7] = 0;
                              heapClassInst.heap32[r20 + numDefine8] = 0;
                              heapClassInst.heap32[r20 + numDefine9] = 0;
                              heapClassInst.heap32[r20 + numDefine10] = 0;
                              heapClassInst.heap32[r20 + numDefine11] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine12] = 0;
                              heapClassInst.heap32[r20 + numDefine13] = 0;
                              heapClassInst.heap32[r20 + numDefine14] = 0;
                              r21 = ztv11btRigidBody;
                              heapClassInst.heap32[r20 + numDefine15] = 0;
                              r21 = (r21 + numDefine8) | 0;
                              heapClassInst.heap32[r20 + numDefine16] = 0;
                              r22 = 1;
                              heapClassInst.heap32[r20] = r21;
                              heapClassInst.heap8[r19 + numDefine492] = r22;
                              heapClassInst.heap32[r20 + numDefine122] = 0;
                              heapClassInst.heap32[r20 + numDefine120] = 0;
                              r21 = sp + numDefineNeg144;
                              heapClassInst.heap32[r20 + numDefine121] = 0;
                              r20 = r21 >> numDefine2;
                              heapClassInst.heap32[fp + numDefineNeg36] = 0;
                              heapClassInst.heap32[r20 + 1] = 0;
                              heapClassInst.heap32[r20 + numDefine18] = 0;
                              heapClassInst.heap32[r20 + numDefine19] = 0;
                              heapClassInst.heap32[r20 + numDefine20] = 0;
                              heapClassInst.heap32[r20 + numDefine21] = 0;
                              heapClassInst.heap32[r20 + numDefine22] = 0;
                              heapClassInst.heap32[r20 + numDefine23] = 0;
                              heapClassInst.heap32[r20 + numDefine24] = 0;
                              heapClassInst.heap32[r20 + numDefine25] = numDefine64608;
                              heapClassInst.heap32[r20 + numDefine26] = 0;
                              heapClassInst.heap32[r20 + numDefine27] = numDefine97773;
                              heapClassInst.heap32[r20 + numDefine28] = numDefine53216;
                              heapClassInst.heap8[sp + numDefineNeg28] = r16;
                              heapClassInst.heap32[r20 + numDefine30] = numDefine93162;
                              heapClassInst.heap32[r20 + numDefine31] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine32] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine33] = numDefine81770;
                              heapClassInst.heap32[r20 + numDefine2] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine3] = 0;
                              heapClassInst.heap32[r20 + numDefine4] = 0;
                              heapClassInst.heap32[r20 + numDefine5] = 0;
                              heapClassInst.heap32[r20 + numDefine6] = 0;
                              heapClassInst.heap32[r20 + numDefine7] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine8] = 0;
                              heapClassInst.heap32[r20 + numDefine9] = 0;
                              heapClassInst.heap32[r20 + numDefine10] = 0;
                              heapClassInst.heap32[r20 + numDefine11] = 0;
                              heapClassInst.heap32[r20 + numDefine12] = numDefine53216;
                              heapClassInst.heap32[r20 + numDefine13] = 0;
                              heapClassInst.heap32[r20 + numDefine14] = 0;
                              heapClassInst.heap32[r20 + numDefine15] = 0;
                              heapClassInst.heap32[r20 + numDefine16] = 0;
                              heapClassInst.heap32[r20 + numDefine17] = 0;
                              heapClassInst.heap32[g0] = r19;
                              heapClassInst.heap32[g0 + 1] = r21;
                              zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
                              heapClassInst.heap8[r18] = r22;
                            }
                            r18 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
                            r19 = r18 >> numDefine2;
                            r20 = heapClassInst.heap32[r19 + numDefine51];
                            r20 = r20 | 1;
                            heapClassInst.heap32[r19 + numDefine51] = r20;
                            heapClassInst.heap32[r19 + numDefine84] = 0;
                            f0 = 0;
                            f1 = heapClassInst.heapFloat[r19 + numDefine95];
                            f2 = heapClassInst.heapFloat[r19 + numDefine94];
                            f3 = heapClassInst.heapFloat[r19 + numDefine93];
                            f3 = f3 * f0;
                            f2 = f2 * f0;
                            heapClassInst.heapFloat[r19 + numDefine89] = f3;
                            f1 = f1 * f0;
                            heapClassInst.heapFloat[r19 + numDefine90] = f2;
                            heapClassInst.heapFloat[r19 + numDefine91] = f1;
                            heapClassInst.heap32[r19 + numDefine92] = 0;
                            heapClassInst.heap32[r19 + numDefine97] = 0;
                            heapClassInst.heap32[r19 + numDefine98] = 0;
                            heapClassInst.heap32[r19 + numDefine99] = 0;
                            heapClassInst.heap32[r19 + numDefine100] = 0;
                            f1 = heapClassInst.heapFloat[r19 + numDefine87];
                            f2 = heapClassInst.heapFloat[r19 + numDefine86];
                            f3 = heapClassInst.heapFloat[r19 + numDefine85];
                            f3 = f3 * f0;
                            f2 = f2 * f0;
                            heapClassInst.heapFloat[r19 + numDefine138] = f3;
                            f0 = f1 * f0;
                            heapClassInst.heapFloat[r19 + numDefine139] = f2;
                            heapClassInst.heapFloat[r19 + numDefine140] = f0;
                            heapClassInst.heap32[r19 + numDefine141] = 0;
                          } else {
                            r18 = r15;
                          }
                          heapClassInst.heap32[r17 + numDefine27] = r18;
                          r18 = r1 >> numDefine2;
                          heapClassInst.heap32[r17 + numDefine28] = r10;
                          r19 = r3 >> numDefine2;
                          r20 = heapClassInst.heap32[r19 + numDefine58];
                          r21 = heapClassInst.heap32[r18 + numDefine58];
                          f0 = heapClassInst.heapFloat[r9 + numDefine15];
                          f1 = heapClassInst.heapFloat[r19 + numDefine15];
                          f2 = heapClassInst.heapFloat[r9 + numDefine14];
                          f3 = heapClassInst.heapFloat[r19 + numDefine14];
                          f4 = heapClassInst.heapFloat[r9 + numDefine13];
                          f5 = heapClassInst.heapFloat[r19 + numDefine13];
                          r19 = sp + numDefineNeg296;
                          f4 = f4 - f5;
                          f2 = f2 - f3;
                          r22 = r19 >> numDefine2;
                          heapClassInst.heapFloat[fp + numDefineNeg74] = f4;
                          f0 = f0 - f1;
                          heapClassInst.heapFloat[r22 + 1] = f2;
                          heapClassInst.heapFloat[r22 + numDefine2] = f0;
                          heapClassInst.heap32[r22 + numDefine3] = 0;
                          f1 = heapClassInst.heapFloat[r9 + numDefine11];
                          f3 = heapClassInst.heapFloat[r18 + numDefine15];
                          f5 = heapClassInst.heapFloat[r9 + numDefine10];
                          f6 = heapClassInst.heapFloat[r18 + numDefine14];
                          f7 = heapClassInst.heapFloat[r9 + numDefine9];
                          f8 = heapClassInst.heapFloat[r18 + numDefine13];
                          r18 = sp + numDefineNeg312;
                          f7 = f7 - f8;
                          f5 = f5 - f6;
                          r22 = r18 >> numDefine2;
                          heapClassInst.heapFloat[fp + numDefineNeg78] = f7;
                          f1 = f1 - f3;
                          heapClassInst.heapFloat[r22 + 1] = f5;
                          heapClassInst.heapFloat[r22 + numDefine2] = f1;
                          r23 = r8 >> numDefine2;
                          heapClassInst.heap32[r22 + numDefine3] = 0;
                          r22 = r8 >> numDefine2;
                          r24 = r8 >> numDefine2;
                          r20 = r20 & numDefine2;
                          r21 = r21 & numDefine2;
                          r20 = r20 === 0 ? r16 : r3;
                          r16 = r21 === 0 ? r16 : r1;
                          if (r20 === 0) {
                            heapClassInst.heap32[r17 + numDefine12] = 0;
                            heapClassInst.heap32[r17 + numDefine13] = 0;
                            f3 = 0;
                            heapClassInst.heap32[r17 + numDefine14] = 0;
                            heapClassInst.heap32[r17 + numDefine15] = 0;
                            f6 = f3;
                            f8 = f3;
                          } else {
                            f3 = heapClassInst.heapFloat[r23 + numDefine17];
                            f6 = heapClassInst.heapFloat[r22 + numDefine19];
                            f8 = heapClassInst.heapFloat[r24 + numDefine18];
                            f9 = f4 * f8;
                            f10 = f2 * f3;
                            f3 = f0 * f3;
                            f11 = f4 * f6;
                            f6 = f2 * f6;
                            f8 = f0 * f8;
                            f9 = f9 - f10;
                            f3 = f3 - f11;
                            f6 = f6 - f8;
                            r21 = r20 >> numDefine2;
                            f8 = heapClassInst.heapFloat[r21 + numDefine64];
                            f10 = heapClassInst.heapFloat[r21 + numDefine65];
                            f11 = heapClassInst.heapFloat[r21 + numDefine68];
                            f12 = heapClassInst.heapFloat[r21 + numDefine69];
                            f8 = f8 * f6;
                            f10 = f10 * f3;
                            f13 = heapClassInst.heapFloat[r21 + numDefine66];
                            f14 = heapClassInst.heapFloat[r21 + numDefine72];
                            f15 = heapClassInst.heapFloat[r21 + numDefine73];
                            f16 = heapClassInst.heapFloat[r21 + numDefine70];
                            f11 = f11 * f6;
                            f12 = f12 * f3;
                            f8 = f8 + f10;
                            f10 = f13 * f9;
                            f13 = heapClassInst.heapFloat[r21 + numDefine74];
                            f6 = f14 * f6;
                            f3 = f15 * f3;
                            f11 = f11 + f12;
                            f12 = f16 * f9;
                            f8 = f8 + f10;
                            f10 = heapClassInst.heapFloat[r21 + numDefine134];
                            f14 = heapClassInst.heapFloat[r21 + numDefine136];
                            f15 = heapClassInst.heapFloat[r21 + numDefine135];
                            f11 = f11 + f12;
                            f8 = f8 * f10;
                            f3 = f6 + f3;
                            f6 = f13 * f9;
                            f3 = f3 + f6;
                            f6 = f11 * f15;
                            heapClassInst.heapFloat[r17 + numDefine12] = f8;
                            f3 = f3 * f14;
                            heapClassInst.heapFloat[r17 + numDefine13] = f6;
                            heapClassInst.heapFloat[r17 + numDefine14] = f3;
                            heapClassInst.heap32[r17 + numDefine15] = 0;
                          }
                          if (r16 === 0) {
                            heapClassInst.heap32[r17 + numDefine16] = 0;
                            heapClassInst.heap32[r17 + numDefine17] = 0;
                            f10 = 0;
                            heapClassInst.heap32[r17 + numDefine18] = 0;
                            heapClassInst.heap32[r17 + numDefine19] = 0;
                            f11 = f10;
                            f9 = f10;
                          } else {
                            f9 = heapClassInst.heapFloat[r24 + numDefine18];
                            f10 = heapClassInst.heapFloat[r23 + numDefine17];
                            f11 = heapClassInst.heapFloat[r22 + numDefine19];
                            f12 = f5 * f11;
                            f13 = f1 * f9;
                            r21 = r16 >> numDefine2;
                            f12 = f12 - f13;
                            f13 = f1 * f10;
                            f11 = f7 * f11;
                            f12 = -f12;
                            f14 = heapClassInst.heapFloat[r21 + numDefine64];
                            f11 = f13 - f11;
                            f13 = heapClassInst.heapFloat[r21 + numDefine65];
                            f9 = f7 * f9;
                            f10 = f5 * f10;
                            f15 = heapClassInst.heapFloat[r21 + numDefine68];
                            f16 = heapClassInst.heapFloat[r21 + numDefine69];
                            f14 = f14 * f12;
                            f13 = f13 * f11;
                            f9 = f9 - f10;
                            f10 = heapClassInst.heapFloat[r21 + numDefine66];
                            f17 = heapClassInst.heapFloat[r21 + numDefine72];
                            f18 = heapClassInst.heapFloat[r21 + numDefine73];
                            f19 = heapClassInst.heapFloat[r21 + numDefine70];
                            f15 = f15 * f12;
                            f16 = f16 * f11;
                            f13 = f14 - f13;
                            f10 = f10 * f9;
                            f14 = heapClassInst.heapFloat[r21 + numDefine74];
                            f12 = f17 * f12;
                            f11 = f18 * f11;
                            f15 = f15 - f16;
                            f16 = f19 * f9;
                            f10 = f13 - f10;
                            f13 = heapClassInst.heapFloat[r21 + numDefine134];
                            f17 = heapClassInst.heapFloat[r21 + numDefine136];
                            f18 = heapClassInst.heapFloat[r21 + numDefine135];
                            f15 = f15 - f16;
                            f10 = f10 * f13;
                            f11 = f12 - f11;
                            f9 = f14 * f9;
                            f9 = f11 - f9;
                            f11 = f15 * f18;
                            heapClassInst.heapFloat[r17 + numDefine16] = f10;
                            f9 = f9 * f17;
                            heapClassInst.heapFloat[r17 + numDefine17] = f11;
                            heapClassInst.heapFloat[r17 + numDefine18] = f9;
                            heapClassInst.heap32[r17 + numDefine19] = 0;
                          }
                          if (r20 !== 0) {
                            f12 = f6 * f0;
                            f13 = f3 * f2;
                            f3 = f3 * f4;
                            f14 = f8 * f0;
                            f15 = heapClassInst.heapFloat[r23 + numDefine17];
                            f12 = f12 - f13;
                            f13 = heapClassInst.heapFloat[r24 + numDefine18];
                            f3 = f3 - f14;
                            f8 = f8 * f2;
                            f6 = f6 * f4;
                            f12 = f15 * f12;
                            f3 = f13 * f3;
                            f13 = heapClassInst.heapFloat[r22 + numDefine19];
                            f6 = f8 - f6;
                            r21 = r20 >> numDefine2;
                            f3 = f12 + f3;
                            f6 = f13 * f6;
                            f8 = heapClassInst.heapFloat[r21 + numDefine84];
                            f3 = f3 + f6;
                            f3 = f8 + f3;
                          } else {
                            f3 = 0;
                          }
                          if (r16 !== 0) {
                            f6 = f5 * f9;
                            f8 = f1 * f11;
                            f12 = f1 * f10;
                            f9 = f7 * f9;
                            f13 = heapClassInst.heapFloat[r23 + numDefine17];
                            f6 = f6 - f8;
                            f8 = heapClassInst.heapFloat[r24 + numDefine18];
                            f9 = f12 - f9;
                            f11 = f7 * f11;
                            f10 = f5 * f10;
                            f6 = f13 * f6;
                            f9 = f8 * f9;
                            f8 = heapClassInst.heapFloat[r22 + numDefine19];
                            f10 = f11 - f10;
                            r21 = r16 >> numDefine2;
                            f9 = f6 + f9;
                            f6 = f8 * f10;
                            f8 = heapClassInst.heapFloat[r21 + numDefine84];
                            f9 = f9 + f6;
                            f9 = f8 + f9;
                          } else {
                            f9 = 0;
                          }
                          f6 = 1;
                          f3 = f3 + f9;
                          f3 = f6 / f3;
                          heapClassInst.heapFloat[r17 + numDefine23] = f3;
                          f3 = heapClassInst.heapFloat[r23 + numDefine17];
                          heapClassInst.heapFloat[r17 + numDefine4] = f3;
                          f8 = heapClassInst.heapFloat[r24 + numDefine18];
                          heapClassInst.heapFloat[r17 + numDefine5] = f8;
                          f9 = heapClassInst.heapFloat[r22 + numDefine19];
                          heapClassInst.heapFloat[r17 + numDefine6] = f9;
                          heapClassInst.heap32[r17 + numDefine7] = heapClassInst.heap32[r9 + numDefine20];
                          f10 = heapClassInst.heapFloat[r22 + numDefine19];
                          f11 = heapClassInst.heapFloat[r24 + numDefine18];
                          f12 = heapClassInst.heapFloat[r23 + numDefine17];
                          f13 = f2 * f10;
                          f14 = f0 * f11;
                          f15 = f0 * f12;
                          f10 = f4 * f10;
                          f13 = f13 - f14;
                          f11 = f4 * f11;
                          f12 = f2 * f12;
                          f10 = f15 - f10;
                          heapClassInst.heapFloat[r17] = f13;
                          f11 = f11 - f12;
                          heapClassInst.heapFloat[r17 + 1] = f10;
                          heapClassInst.heapFloat[r17 + numDefine2] = f11;
                          heapClassInst.heap32[r17 + numDefine3] = 0;
                          f10 = heapClassInst.heapFloat[r24 + numDefine18];
                          f11 = heapClassInst.heapFloat[r22 + numDefine19];
                          f12 = heapClassInst.heapFloat[r23 + numDefine17];
                          f13 = f1 * f10;
                          f14 = f5 * f11;
                          f11 = f7 * f11;
                          f15 = f1 * f12;
                          f13 = f13 - f14;
                          f12 = f5 * f12;
                          f10 = f7 * f10;
                          f11 = f11 - f15;
                          heapClassInst.heapFloat[r17 + numDefine8] = f13;
                          f10 = f12 - f10;
                          heapClassInst.heapFloat[r17 + numDefine9] = f11;
                          heapClassInst.heapFloat[r17 + numDefine10] = f10;
                          heapClassInst.heap32[r17 + numDefine11] = 0;
                          if (r20 !== 0) {
                            r21 = r20 >> numDefine2;
                            f10 = heapClassInst.heapFloat[r21 + numDefine81];
                            f11 = heapClassInst.heapFloat[r21 + numDefine80];
                            f12 = heapClassInst.heapFloat[r21 + numDefine82];
                            f13 = f11 * f2;
                            f14 = f10 * f4;
                            f4 = f12 * f4;
                            f11 = f11 * f0;
                            f0 = f10 * f0;
                            f2 = f12 * f2;
                            f10 = heapClassInst.heapFloat[r21 + numDefine78];
                            f12 = f13 - f14;
                            f13 = heapClassInst.heapFloat[r21 + numDefine77];
                            f11 = f4 - f11;
                            f14 = heapClassInst.heapFloat[r21 + numDefine76];
                            f0 = f0 - f2;
                            f4 = f10 + f12;
                            f2 = f13 + f11;
                            f0 = f14 + f0;
                          } else {
                            f0 = 0;
                            f2 = f0;
                            f4 = f0;
                          }
                          if (r16 !== 0) {
                            r21 = r16 >> numDefine2;
                            f10 = heapClassInst.heapFloat[r21 + numDefine81];
                            f11 = heapClassInst.heapFloat[r21 + numDefine80];
                            f12 = heapClassInst.heapFloat[r21 + numDefine82];
                            f13 = f11 * f5;
                            f14 = f10 * f7;
                            f7 = f12 * f7;
                            f11 = f11 * f1;
                            f1 = f10 * f1;
                            f5 = f12 * f5;
                            f10 = heapClassInst.heapFloat[r21 + numDefine78];
                            f12 = f13 - f14;
                            f13 = heapClassInst.heapFloat[r21 + numDefine77];
                            f11 = f7 - f11;
                            f14 = heapClassInst.heapFloat[r21 + numDefine76];
                            f1 = f1 - f5;
                            f7 = f10 + f12;
                            f5 = f13 + f11;
                            f1 = f14 + f1;
                          } else {
                            f1 = 0;
                            f5 = f1;
                            f7 = f1;
                          }
                          f0 = f0 - f1;
                          f1 = f2 - f5;
                          f2 = heapClassInst.heapFloat[r23 + numDefine17];
                          f5 = heapClassInst.heapFloat[r24 + numDefine18];
                          f4 = f4 - f7;
                          f7 = heapClassInst.heapFloat[r22 + numDefine19];
                          f2 = f2 * f0;
                          f5 = f5 * f1;
                          f2 = f2 + f5;
                          f5 = f7 * f4;
                          f7 = heapClassInst.heapFloat[r9 + numDefine21];
                          f10 = heapClassInst.heapFloat[r6 + numDefine13];
                          f2 = f2 + f5;
                          f5 = f7 + f10;
                          heapClassInst.heap32[r17 + numDefine22] = heapClassInst.heap32[r9 + numDefine22];
                          r21 = heapClassInst.heap32[r9 + numDefine37];
                          r25 = heapClassInst.heap32[r6 + numDefine16];
                          if (r21 > r25) {
                            label = numDefine151;
                          } else {
                            f7 = heapClassInst.heapFloat[r9 + numDefine23];
                            f10 = -f2;
                            f7 = f7 * f10;
                            f10 = 0;
                            if (f7 <= f10) {
                              label = numDefine151;
                            } else {
                              label = numDefine152;
                            }
                          }
                          if (label === numDefine151) {
                            f7 = 0;
                          }
                          r21 = heapClassInst.heapU8[r5 + numDefine60];
                          r21 = r21 & numDefine4;
                          if (r21 === 0) {
                            heapClassInst.heap32[r17 + numDefine21] = 0;
                          } else {
                            f10 = heapClassInst.heapFloat[r9 + numDefine29];
                            f11 = heapClassInst.heapFloat[r6 + numDefine14];
                            f10 = f10 * f11;
                            heapClassInst.heapFloat[r17 + numDefine21] = f10;
                            if (!(r20 === 0)) {
                              r21 = r20 >> numDefine2;
                              f11 = heapClassInst.heapFloat[r21 + numDefine84];
                              f12 = 0;
                              if (!(f11 === f12)) {
                                f3 = f3 * f11;
                                f12 = heapClassInst.heapFloat[r21 + numDefine85];
                                f3 = f3 * f12;
                                f3 = f3 * f10;
                                f12 = heapClassInst.heapFloat[r21 + numDefine126];
                                f13 = heapClassInst.heapFloat[r21 + numDefine86];
                                f14 = heapClassInst.heapFloat[r21 + numDefine87];
                                f8 = f8 * f11;
                                f3 = f12 + f3;
                                f8 = f8 * f13;
                                heapClassInst.heapFloat[r21 + numDefine126] = f3;
                                f3 = f8 * f10;
                                f8 = heapClassInst.heapFloat[r21 + numDefine127];
                                f9 = f9 * f11;
                                f3 = f8 + f3;
                                f8 = f9 * f14;
                                heapClassInst.heapFloat[r21 + numDefine127] = f3;
                                f3 = f8 * f10;
                                f8 = heapClassInst.heapFloat[r21 + numDefine128];
                                f3 = f8 + f3;
                                heapClassInst.heapFloat[r21 + numDefine128] = f3;
                                f3 = heapClassInst.heapFloat[r21 + numDefine134];
                                f3 = f3 * f10;
                                f8 = heapClassInst.heapFloat[r17 + numDefine12];
                                f9 = heapClassInst.heapFloat[r21 + numDefine136];
                                f11 = heapClassInst.heapFloat[r21 + numDefine135];
                                f3 = f8 * f3;
                                f8 = heapClassInst.heapFloat[r21 + numDefine130];
                                f12 = heapClassInst.heapFloat[r17 + numDefine14];
                                f13 = heapClassInst.heapFloat[r17 + numDefine13];
                                f3 = f8 + f3;
                                f8 = f11 * f10;
                                heapClassInst.heapFloat[r21 + numDefine130] = f3;
                                f3 = f13 * f8;
                                f8 = heapClassInst.heapFloat[r21 + numDefine131];
                                f3 = f8 + f3;
                                f8 = f9 * f10;
                                heapClassInst.heapFloat[r21 + numDefine131] = f3;
                                f3 = f12 * f8;
                                f8 = heapClassInst.heapFloat[r21 + numDefine132];
                                f3 = f8 + f3;
                                heapClassInst.heapFloat[r21 + numDefine132] = f3;
                              }
                            }
                            if (!(r16 === 0)) {
                              r21 = r16 >> numDefine2;
                              f3 = heapClassInst.heapFloat[r21 + numDefine84];
                              f8 = 0;
                              if (!(f3 === f8)) {
                                f8 = heapClassInst.heapFloat[r17 + numDefine21];
                                f8 = -f8;
                                f9 = heapClassInst.heapFloat[r17 + numDefine4];
                                f9 = f9 * f3;
                                f10 = heapClassInst.heapFloat[r21 + numDefine85];
                                f9 = f9 * f10;
                                f10 = heapClassInst.heapFloat[r17 + numDefine5];
                                f11 = heapClassInst.heapFloat[r17 + numDefine6];
                                f9 = f9 * f8;
                                f12 = heapClassInst.heapFloat[r21 + numDefine126];
                                f13 = heapClassInst.heapFloat[r21 + numDefine86];
                                f14 = heapClassInst.heapFloat[r21 + numDefine87];
                                f15 = heapClassInst.heapFloat[r17 + numDefine16];
                                f16 = heapClassInst.heapFloat[r17 + numDefine17];
                                f17 = heapClassInst.heapFloat[r17 + numDefine18];
                                f10 = f10 * f3;
                                f9 = f12 + f9;
                                f10 = f10 * f13;
                                heapClassInst.heapFloat[r21 + numDefine126] = f9;
                                f9 = f10 * f8;
                                f10 = heapClassInst.heapFloat[r21 + numDefine127];
                                f3 = f11 * f3;
                                f9 = f10 + f9;
                                f3 = f3 * f14;
                                heapClassInst.heapFloat[r21 + numDefine127] = f9;
                                f3 = f3 * f8;
                                f9 = heapClassInst.heapFloat[r21 + numDefine128];
                                f3 = f9 + f3;
                                heapClassInst.heapFloat[r21 + numDefine128] = f3;
                                f3 = heapClassInst.heapFloat[r21 + numDefine134];
                                f3 = f3 * f8;
                                f9 = heapClassInst.heapFloat[r21 + numDefine136];
                                f10 = heapClassInst.heapFloat[r21 + numDefine135];
                                f11 = heapClassInst.heapFloat[r21 + numDefine130];
                                f3 = f3 * f15;
                                f3 = f11 - f3;
                                f10 = f10 * f8;
                                heapClassInst.heapFloat[r21 + numDefine130] = f3;
                                f3 = f10 * f16;
                                f10 = heapClassInst.heapFloat[r21 + numDefine131];
                                f3 = f10 - f3;
                                f8 = f9 * f8;
                                heapClassInst.heapFloat[r21 + numDefine131] = f3;
                                f3 = f8 * f17;
                                f8 = heapClassInst.heapFloat[r21 + numDefine132];
                                f3 = f8 - f3;
                                heapClassInst.heapFloat[r21 + numDefine132] = f3;
                              }
                            }
                          }
                          heapClassInst.heap32[r17 + numDefine20] = 0;
                          if (r20 !== 0) {
                            r21 = r20 >> numDefine2;
                            f9 = heapClassInst.heapFloat[r21 + numDefine76];
                            f8 = heapClassInst.heapFloat[r21 + numDefine77];
                            f3 = heapClassInst.heapFloat[r21 + numDefine78];
                          } else {
                            f3 = 0;
                            f8 = f3;
                            f9 = f3;
                          }
                          f10 = heapClassInst.heapFloat[r17 + numDefine4];
                          f11 = heapClassInst.heapFloat[r17 + numDefine5];
                          f12 = heapClassInst.heapFloat[r17 + numDefine6];
                          f9 = f10 * f9;
                          f8 = f11 * f8;
                          f8 = f9 + f8;
                          f3 = f12 * f3;
                          f3 = f8 + f3;
                          if (r20 !== 0) {
                            r20 = r20 >> numDefine2;
                            f13 = heapClassInst.heapFloat[r20 + numDefine80];
                            f9 = heapClassInst.heapFloat[r20 + numDefine81];
                            f8 = heapClassInst.heapFloat[r20 + numDefine82];
                          } else {
                            f8 = 0;
                            f9 = f8;
                            f13 = f8;
                          }
                          f14 = heapClassInst.heapFloat[r17];
                          f15 = heapClassInst.heapFloat[r17 + 1];
                          f13 = f14 * f13;
                          f9 = f15 * f9;
                          f14 = heapClassInst.heapFloat[r17 + numDefine2];
                          f9 = f13 + f9;
                          f8 = f14 * f8;
                          f8 = f9 + f8;
                          f3 = f3 + f8;
                          if (r16 !== 0) {
                            r20 = r16 >> numDefine2;
                            f13 = heapClassInst.heapFloat[r20 + numDefine80];
                            f9 = heapClassInst.heapFloat[r20 + numDefine81];
                            f8 = heapClassInst.heapFloat[r20 + numDefine82];
                          } else {
                            f8 = 0;
                            f9 = f8;
                            f13 = f8;
                          }
                          f14 = heapClassInst.heapFloat[r17 + numDefine8];
                          f15 = heapClassInst.heapFloat[r17 + numDefine9];
                          f13 = f14 * f13;
                          f9 = f15 * f9;
                          f14 = heapClassInst.heapFloat[r17 + numDefine10];
                          f9 = f13 + f9;
                          f8 = f14 * f8;
                          f8 = f9 + f8;
                          if (r16 !== 0) {
                            r16 = r16 >> numDefine2;
                            f14 = heapClassInst.heapFloat[r16 + numDefine76];
                            f13 = heapClassInst.heapFloat[r16 + numDefine77];
                            f9 = heapClassInst.heapFloat[r16 + numDefine78];
                          } else {
                            f9 = 0;
                            f13 = f9;
                            f14 = f9;
                          }
                          f10 = f10 * f14;
                          f11 = f11 * f13;
                          f10 = f10 + f11;
                          f9 = f12 * f9;
                          f9 = f10 + f9;
                          f10 = heapClassInst.heapFloat[r6 + numDefine8];
                          f11 = -f5;
                          f8 = f8 - f9;
                          f9 = f10 * f11;
                          f10 = heapClassInst.heapFloat[r6 + numDefine3];
                          f3 = f3 + f8;
                          f8 = f9 / f10;
                          f9 = heapClassInst.heapFloat[r17 + numDefine23];
                          f3 = f7 - f3;
                          f7 = f9 * f8;
                          f3 = f9 * f3;
                          r16 = heapClassInst.heap32[r6 + numDefine11];
                          if (r16 === 0) {
                            label = numDefine174;
                          } else {
                            f8 = heapClassInst.heapFloat[r6 + numDefine12];
                            if (f8 >= f5) {
                              heapClassInst.heapFloat[r17 + numDefine29] = f3;
                              heapClassInst.heapFloat[r17 + numDefine33] = f7;
                              label = numDefine176;
                            } else {
                              label = numDefine174;
                            }
                          }
                          if (label === numDefine174) {
                            f3 = f7 + f3;
                            heapClassInst.heapFloat[r17 + numDefine29] = f3;
                            heapClassInst.heap32[r17 + numDefine33] = 0;
                          }
                          heapClassInst.heap32[r17 + numDefine30] = 0;
                          heapClassInst.heap32[r17 + numDefine31] = 0;
                          heapClassInst.heap32[r17 + numDefine32] = numDefine54297;
                          r16 = heapClassInst.heap32[r2 + numDefine12];
                          heapClassInst.heap32[r17 + numDefine25] = r16;
                          r16 = heapClassInst.heapU8[r5 + numDefine60];
                          r16 = r16 & numDefine32;
                          if (r16 === 0) {
                            label = numDefine178;
                          } else {
                            r16 = heapClassInst.heapU8[r8 + numDefine120];
                            if (r16 !== 0) {
                              r16 = r8 >> numDefine2;
                              f0 = heapClassInst.heapFloat[r9 + numDefine35];
                              f1 = heapClassInst.heapFloat[r16 + numDefine33];
                              heapClassInst.heap32[g0] = r0;
                              heapClassInst.heap32[g0 + 1] = r12;
                              heapClassInst.heap32[g0 + numDefine2] = r14;
                              heapClassInst.heap32[g0 + numDefine3] = r10;
                              heapClassInst.heap32[g0 + numDefine4] = r19;
                              heapClassInst.heap32[g0 + numDefine5] = r18;
                              heapClassInst.heap32[g0 + numDefine6] = r3;
                              heapClassInst.heap32[g0 + numDefine7] = r1;
                              heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                              heapClassInst.heapFloat[g0 + numDefine9] = f1;
                              heapClassInst.heapFloat[g0 + numDefine10] = f0;
                              zn35btSVector3P11(i7);
                              r12 = heapClassInst.heapU8[r5 + numDefine60];
                              r12 = r12 & numDefine16;
                              if (r12 === 0) {
                                label = numDefine194;
                              } else {
                                r12 = r8 >> numDefine2;
                                r8 = r8 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r12 + numDefine36];
                                f1 = heapClassInst.heapFloat[r8 + numDefine34];
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r11;
                                heapClassInst.heap32[g0 + numDefine2] = r14;
                                heapClassInst.heap32[g0 + numDefine3] = r10;
                                heapClassInst.heap32[g0 + numDefine4] = r19;
                                heapClassInst.heap32[g0 + numDefine5] = r18;
                                heapClassInst.heap32[g0 + numDefine6] = r3;
                                heapClassInst.heap32[g0 + numDefine7] = r1;
                                heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                                heapClassInst.heapFloat[g0 + numDefine9] = f1;
                                heapClassInst.heapFloat[g0 + numDefine10] = f0;
                                zn35btSVector3P11(i7);
                                label = numDefine194;
                              }
                            } else {
                              label = numDefine178;
                            }
                          }
                          repeat259: do {
                            if (label === numDefine178) {
                              f3 = heapClassInst.heapFloat[r23 + numDefine17];
                              f5 = heapClassInst.heapFloat[r22 + numDefine19];
                              f7 = heapClassInst.heapFloat[r24 + numDefine18];
                              f8 = f3 * f2;
                              f0 = f0 - f8;
                              f8 = f7 * f2;
                              r16 = r8 >> numDefine2;
                              f1 = f1 - f8;
                              f2 = f5 * f2;
                              r20 = r8 >> numDefine2;
                              heapClassInst.heapFloat[r16 + numDefine38] = f0;
                              f2 = f4 - f2;
                              r21 = r8 >> numDefine2;
                              heapClassInst.heapFloat[r20 + numDefine39] = f1;
                              r25 = r8 >> numDefine2;
                              heapClassInst.heapFloat[r21 + numDefine40] = f2;
                              heapClassInst.heap32[r25 + numDefine41] = 0;
                              r25 = heapClassInst.heapU8[r5 + numDefine60];
                              r25 = r25 & numDefine64;
                              if (!(r25 !== 0)) {
                                f0 = f0 * f0;
                                f1 = f1 * f1;
                                f0 = f0 + f1;
                                f1 = f2 * f2;
                                f0 = f0 + f1;
                                f1 = numDefineFloat1257;
                                if (!(f0 <= f1)) {
                                  heapClassInst.heapFloat[g0] = f0;
                                  sqrtf(i7);
                                  f3 = f6 / commonVariable.fg0;
                                  f5 = heapClassInst.heapFloat[r16 + numDefine38];
                                  f5 = f5 * f3;
                                  heapClassInst.heapFloat[r16 + numDefine38] = f5;
                                  f7 = heapClassInst.heapFloat[r20 + numDefine39];
                                  f7 = f7 * f3;
                                  heapClassInst.heapFloat[r20 + numDefine39] = f7;
                                  f0 = heapClassInst.heapFloat[r21 + numDefine40];
                                  f3 = f0 * f3;
                                  heapClassInst.heapFloat[r21 + numDefine40] = f3;
                                  r16 = heapClassInst.heapU8[r5 + numDefine60];
                                  r16 = r16 & numDefine16;
                                  if (!(r16 === 0)) {
                                    f0 = heapClassInst.heapFloat[r22 + numDefine19];
                                    f1 = heapClassInst.heapFloat[r24 + numDefine18];
                                    f2 = heapClassInst.heapFloat[r23 + numDefine17];
                                    f4 = f7 * f0;
                                    f8 = f3 * f1;
                                    f4 = f4 - f8;
                                    f3 = f3 * f2;
                                    f0 = f5 * f0;
                                    r16 = r8 >> numDefine2;
                                    f3 = f3 - f0;
                                    f5 = f5 * f1;
                                    f7 = f7 * f2;
                                    r20 = r8 >> numDefine2;
                                    heapClassInst.heapFloat[r16 + numDefine42] = f4;
                                    f5 = f5 - f7;
                                    r21 = r8 >> numDefine2;
                                    heapClassInst.heapFloat[r20 + numDefine43] = f3;
                                    f7 = f4 * f4;
                                    f3 = f3 * f3;
                                    r22 = r8 >> numDefine2;
                                    heapClassInst.heapFloat[r21 + numDefine44] = f5;
                                    heapClassInst.heap32[r22 + numDefine45] = 0;
                                    f3 = f7 + f3;
                                    f5 = f5 * f5;
                                    f3 = f3 + f5;
                                    heapClassInst.heapFloat[g0] = f3;
                                    sqrtf(i7);
                                    f3 = f6 / commonVariable.fg0;
                                    f5 = heapClassInst.heapFloat[r16 + numDefine42];
                                    f5 = f5 * f3;
                                    heapClassInst.heapFloat[r16 + numDefine42] = f5;
                                    f5 = heapClassInst.heapFloat[r20 + numDefine43];
                                    f5 = f5 * f3;
                                    heapClassInst.heapFloat[r20 + numDefine43] = f5;
                                    f5 = heapClassInst.heapFloat[r21 + numDefine44];
                                    f3 = f5 * f3;
                                    heapClassInst.heapFloat[r21 + numDefine44] = f3;
                                    heapClassInst.heap32[g0] = r3;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                    heapClassInst.heap32[g0] = r1;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r11;
                                    heapClassInst.heap32[g0 + numDefine2] = r14;
                                    heapClassInst.heap32[g0 + numDefine3] = r10;
                                    heapClassInst.heap32[g0 + numDefine4] = r19;
                                    heapClassInst.heap32[g0 + numDefine5] = r18;
                                    heapClassInst.heap32[g0 + numDefine6] = r3;
                                    heapClassInst.heap32[g0 + numDefine7] = r1;
                                    heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                                    heapClassInst.heap32[g0 + numDefine9] = 0;
                                    heapClassInst.heap32[g0 + numDefine10] = 0;
                                    zn35btSVector3P11(i7);
                                  }
                                  heapClassInst.heap32[g0] = r3;
                                  heapClassInst.heap32[g0 + 1] = r12;
                                  z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                  heapClassInst.heap32[g0] = r1;
                                  heapClassInst.heap32[g0 + 1] = r12;
                                  z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                  heapClassInst.heap32[g0] = r0;
                                  heapClassInst.heap32[g0 + 1] = r12;
                                  heapClassInst.heap32[g0 + numDefine2] = r14;
                                  heapClassInst.heap32[g0 + numDefine3] = r10;
                                  heapClassInst.heap32[g0 + numDefine4] = r19;
                                  heapClassInst.heap32[g0 + numDefine5] = r18;
                                  heapClassInst.heap32[g0 + numDefine6] = r3;
                                  heapClassInst.heap32[g0 + numDefine7] = r1;
                                  heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                                  heapClassInst.heap32[g0 + numDefine9] = 0;
                                  heapClassInst.heap32[g0 + numDefine10] = 0;
                                  r10 = 1;
                                  zn35btSVector3P11(i7);
                                  heapClassInst.heap8[r8 + numDefine120] = r10;
                                  break repeat259;
                                }
                              }
                              f0 = 0;
                              if (f5 < f0) {
                                f0 = -f5;
                              } else {
                                f0 = f5;
                              }
                              f1 = numDefineFloat742;
                              if (f0 <= f1) {
                                f3 = f3 * f3;
                                f0 = f7 * f7;
                                f3 = f3 + f0;
                                heapClassInst.heapFloat[g0] = f3;
                                sqrtf(i7);
                                f1 = heapClassInst.heapFloat[r24 + numDefine18];
                                f0 = f6 / commonVariable.fg0;
                                f1 = -f1;
                                f1 = f0 * f1;
                                heapClassInst.heapFloat[r16 + numDefine38] = f1;
                                f2 = heapClassInst.heapFloat[r23 + numDefine17];
                                f2 = f2 * f0;
                                heapClassInst.heapFloat[r20 + numDefine39] = f2;
                                heapClassInst.heap32[r21 + numDefine40] = 0;
                                f4 = heapClassInst.heapFloat[r22 + numDefine19];
                                f5 = -f4;
                                r16 = r8 >> numDefine2;
                                f2 = f2 * f5;
                                f3 = f3 * f0;
                                r20 = r8 >> numDefine2;
                                f0 = f4 * f1;
                                heapClassInst.heapFloat[r16 + numDefine42] = f2;
                                heapClassInst.heapFloat[r20 + numDefine43] = f0;
                              } else {
                                f3 = f7 * f7;
                                f7 = f5 * f5;
                                f3 = f3 + f7;
                                heapClassInst.heapFloat[g0] = f3;
                                sqrtf(i7);
                                heapClassInst.heap32[r16 + numDefine38] = 0;
                                f0 = heapClassInst.heapFloat[r22 + numDefine19];
                                f6 = f6 / commonVariable.fg0;
                                f7 = -f0;
                                f7 = f6 * f7;
                                heapClassInst.heapFloat[r20 + numDefine39] = f7;
                                f0 = heapClassInst.heapFloat[r24 + numDefine18];
                                f0 = f0 * f6;
                                r16 = r8 >> numDefine2;
                                f3 = f3 * f6;
                                heapClassInst.heapFloat[r21 + numDefine40] = f0;
                                heapClassInst.heapFloat[r16 + numDefine42] = f3;
                                f3 = heapClassInst.heapFloat[r23 + numDefine17];
                                f6 = -f3;
                                f3 = f3 * f7;
                                r16 = r8 >> numDefine2;
                                f6 = f0 * f6;
                                heapClassInst.heapFloat[r16 + numDefine43] = f6;
                              }
                              r16 = r8 >> numDefine2;
                              heapClassInst.heapFloat[r16 + numDefine44] = f3;
                              r16 = heapClassInst.heapU8[r5 + numDefine60];
                              r16 = r16 & numDefine16;
                              if (!(r16 === 0)) {
                                heapClassInst.heap32[g0] = r3;
                                heapClassInst.heap32[g0 + 1] = r11;
                                z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                heapClassInst.heap32[g0] = r1;
                                heapClassInst.heap32[g0 + 1] = r11;
                                z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r11;
                                heapClassInst.heap32[g0 + numDefine2] = r14;
                                heapClassInst.heap32[g0 + numDefine3] = r10;
                                heapClassInst.heap32[g0 + numDefine4] = r19;
                                heapClassInst.heap32[g0 + numDefine5] = r18;
                                heapClassInst.heap32[g0 + numDefine6] = r3;
                                heapClassInst.heap32[g0 + numDefine7] = r1;
                                heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                                heapClassInst.heap32[g0 + numDefine9] = 0;
                                heapClassInst.heap32[g0 + numDefine10] = 0;
                                zn35btSVector3P11(i7);
                              }
                              heapClassInst.heap32[g0] = r3;
                              heapClassInst.heap32[g0 + 1] = r12;
                              z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                              heapClassInst.heap32[g0] = r1;
                              heapClassInst.heap32[g0 + 1] = r12;
                              z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3(i7);
                              heapClassInst.heap32[g0] = r0;
                              heapClassInst.heap32[g0 + 1] = r12;
                              heapClassInst.heap32[g0 + numDefine2] = r14;
                              heapClassInst.heap32[g0 + numDefine3] = r10;
                              heapClassInst.heap32[g0 + numDefine4] = r19;
                              heapClassInst.heap32[g0 + numDefine5] = r18;
                              heapClassInst.heap32[g0 + numDefine6] = r3;
                              heapClassInst.heap32[g0 + numDefine7] = r1;
                              heapClassInst.heap32[g0 + numDefine8] = numDefine53216;
                              heapClassInst.heap32[g0 + numDefine9] = 0;
                              heapClassInst.heap32[g0 + numDefine10] = 0;
                              r10 = 1;
                              zn35btSVector3P11(i7);
                              heapClassInst.heap8[r8 + numDefine120] = r10;
                            }
                          } while (false);
                          r8 = heapClassInst.heap32[r6 + numDefine15];
                          r10 = heapClassInst.heap32[r17 + numDefine25];
                          r11 = heapClassInst.heap32[r2 + numDefine14];
                          r12 = r8 & numDefine8;
                          if (r12 === 0) {
                            r8 = (r10 * numDefine136) | 0;
                            r8 = (r11 + r8) | 0;
                            r8 = r8 >> numDefine2;
                            heapClassInst.heap32[r8 + numDefine21] = 0;
                            r8 = heapClassInst.heapU8[r5 + numDefine60];
                            r8 = r8 & numDefine16;
                            if (r8 === 0) {
                              break repeat153;
                            } else {
                              r8 = heapClassInst.heap32[r17 + numDefine25];
                              r9 = heapClassInst.heap32[r2 + numDefine14];
                              r8 = (r8 * numDefine136) | 0;
                              r8 = (r8 + r9) | 0;
                              r8 = r8 >> numDefine2;
                              heapClassInst.heap32[r8 + numDefine55] = 0;
                            }
                          } else {
                            r8 = r8 & numDefine4;
                            if (r8 === 0) {
                              r10 = (r10 * numDefine136) | 0;
                              r10 = (r11 + r10) | 0;
                              r10 = r10 >> numDefine2;
                              heapClassInst.heap32[r10 + numDefine21] = 0;
                            } else {
                              r10 = (r10 * numDefine136) | 0;
                              r10 = (r11 + r10) | 0;
                              f0 = heapClassInst.heapFloat[r9 + numDefine31];
                              f1 = heapClassInst.heapFloat[r6 + numDefine14];
                              f0 = f0 * f1;
                              r10 = r10 >> numDefine2;
                              heapClassInst.heapFloat[r10 + numDefine21] = f0;
                              if (!(r13 === 0)) {
                                r11 = r13 >> numDefine2;
                                f1 = heapClassInst.heapFloat[r11 + numDefine84];
                                f2 = 0;
                                if (!(f1 === f2)) {
                                  f2 = heapClassInst.heapFloat[r10 + numDefine4];
                                  f2 = f2 * f1;
                                  f3 = heapClassInst.heapFloat[r11 + numDefine85];
                                  f2 = f2 * f3;
                                  f3 = heapClassInst.heapFloat[r10 + numDefine5];
                                  f4 = heapClassInst.heapFloat[r10 + numDefine6];
                                  f2 = f2 * f0;
                                  f5 = heapClassInst.heapFloat[r11 + numDefine126];
                                  f6 = heapClassInst.heapFloat[r11 + numDefine86];
                                  f7 = heapClassInst.heapFloat[r11 + numDefine87];
                                  f3 = f3 * f1;
                                  f2 = f5 + f2;
                                  f3 = f3 * f6;
                                  heapClassInst.heapFloat[r11 + numDefine126] = f2;
                                  f2 = f3 * f0;
                                  f3 = heapClassInst.heapFloat[r11 + numDefine127];
                                  f1 = f4 * f1;
                                  f2 = f3 + f2;
                                  f1 = f1 * f7;
                                  heapClassInst.heapFloat[r11 + numDefine127] = f2;
                                  f1 = f1 * f0;
                                  f2 = heapClassInst.heapFloat[r11 + numDefine128];
                                  f1 = f2 + f1;
                                  heapClassInst.heapFloat[r11 + numDefine128] = f1;
                                  f1 = heapClassInst.heapFloat[r11 + numDefine134];
                                  f1 = f1 * f0;
                                  f2 = heapClassInst.heapFloat[r10 + numDefine12];
                                  f3 = heapClassInst.heapFloat[r11 + numDefine136];
                                  f4 = heapClassInst.heapFloat[r11 + numDefine135];
                                  f1 = f2 * f1;
                                  f2 = heapClassInst.heapFloat[r11 + numDefine130];
                                  f5 = heapClassInst.heapFloat[r10 + numDefine14];
                                  f6 = heapClassInst.heapFloat[r10 + numDefine13];
                                  f1 = f2 + f1;
                                  f2 = f4 * f0;
                                  heapClassInst.heapFloat[r11 + numDefine130] = f1;
                                  f1 = f6 * f2;
                                  f2 = heapClassInst.heapFloat[r11 + numDefine131];
                                  f1 = f2 + f1;
                                  f0 = f3 * f0;
                                  heapClassInst.heapFloat[r11 + numDefine131] = f1;
                                  f0 = f5 * f0;
                                  f1 = heapClassInst.heapFloat[r11 + numDefine132];
                                  f0 = f1 + f0;
                                  heapClassInst.heapFloat[r11 + numDefine132] = f0;
                                }
                              }
                              if (!(r15 === 0)) {
                                r11 = r15 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r11 + numDefine84];
                                f1 = 0;
                                if (!(f0 === f1)) {
                                  f1 = heapClassInst.heapFloat[r10 + numDefine21];
                                  f1 = -f1;
                                  f2 = heapClassInst.heapFloat[r10 + numDefine4];
                                  f2 = f2 * f0;
                                  f3 = heapClassInst.heapFloat[r11 + numDefine85];
                                  f2 = f2 * f3;
                                  f3 = heapClassInst.heapFloat[r10 + numDefine5];
                                  f4 = heapClassInst.heapFloat[r10 + numDefine6];
                                  f2 = f2 * f1;
                                  f5 = heapClassInst.heapFloat[r11 + numDefine126];
                                  f6 = heapClassInst.heapFloat[r11 + numDefine86];
                                  f7 = heapClassInst.heapFloat[r11 + numDefine87];
                                  f8 = heapClassInst.heapFloat[r10 + numDefine16];
                                  f9 = heapClassInst.heapFloat[r10 + numDefine17];
                                  f10 = heapClassInst.heapFloat[r10 + numDefine18];
                                  f3 = f3 * f0;
                                  f2 = f5 + f2;
                                  f3 = f3 * f6;
                                  heapClassInst.heapFloat[r11 + numDefine126] = f2;
                                  f2 = f3 * f1;
                                  f3 = heapClassInst.heapFloat[r11 + numDefine127];
                                  f0 = f4 * f0;
                                  f2 = f3 + f2;
                                  f0 = f0 * f7;
                                  heapClassInst.heapFloat[r11 + numDefine127] = f2;
                                  f0 = f0 * f1;
                                  f2 = heapClassInst.heapFloat[r11 + numDefine128];
                                  f0 = f2 + f0;
                                  heapClassInst.heapFloat[r11 + numDefine128] = f0;
                                  f0 = heapClassInst.heapFloat[r11 + numDefine134];
                                  f0 = f0 * f1;
                                  f2 = heapClassInst.heapFloat[r11 + numDefine136];
                                  f3 = heapClassInst.heapFloat[r11 + numDefine135];
                                  f4 = heapClassInst.heapFloat[r11 + numDefine130];
                                  f0 = f0 * f8;
                                  f0 = f4 - f0;
                                  f3 = f3 * f1;
                                  heapClassInst.heapFloat[r11 + numDefine130] = f0;
                                  f0 = f3 * f9;
                                  f3 = heapClassInst.heapFloat[r11 + numDefine131];
                                  f0 = f3 - f0;
                                  f1 = f2 * f1;
                                  heapClassInst.heapFloat[r11 + numDefine131] = f0;
                                  f0 = f1 * f10;
                                  f1 = heapClassInst.heapFloat[r11 + numDefine132];
                                  f0 = f1 - f0;
                                  heapClassInst.heapFloat[r11 + numDefine132] = f0;
                                }
                              }
                            }
                            r10 = heapClassInst.heap32[r6 + numDefine15];
                            r11 = r10 & numDefine16;
                            if (!(r11 === 0)) {
                              r11 = heapClassInst.heap32[r17 + numDefine25];
                              r17 = heapClassInst.heap32[r2 + numDefine14];
                              r10 = r10 & numDefine4;
                              if (r10 === 0) {
                                r10 = (r11 * numDefine136) | 0;
                                r10 = (r17 + r10) | 0;
                                r10 = r10 >> numDefine2;
                                heapClassInst.heap32[r10 + numDefine55] = 0;
                              } else {
                                r11 = (r11 * numDefine136) | 0;
                                r11 = (r17 + r11) | 0;
                                f0 = heapClassInst.heapFloat[r9 + numDefine32];
                                f1 = heapClassInst.heapFloat[r6 + numDefine14];
                                f0 = f0 * f1;
                                r11 = r11 >> numDefine2;
                                heapClassInst.heapFloat[r11 + numDefine55] = f0;
                                if (!(r13 === 0)) {
                                  r17 = r13 >> numDefine2;
                                  f1 = heapClassInst.heapFloat[r17 + numDefine84];
                                  f2 = 0;
                                  if (!(f1 === f2)) {
                                    f2 = heapClassInst.heapFloat[r11 + numDefine38];
                                    f2 = f2 * f1;
                                    f3 = heapClassInst.heapFloat[r11 + numDefine39];
                                    f4 = heapClassInst.heapFloat[r11 + numDefine40];
                                    f5 = heapClassInst.heapFloat[r17 + numDefine126];
                                    f2 = f2 * f0;
                                    f2 = f5 + f2;
                                    f3 = f3 * f1;
                                    heapClassInst.heapFloat[r17 + numDefine126] = f2;
                                    f2 = f3 * f0;
                                    f3 = heapClassInst.heapFloat[r17 + numDefine127];
                                    f2 = f3 + f2;
                                    f1 = f4 * f1;
                                    heapClassInst.heapFloat[r17 + numDefine127] = f2;
                                    f1 = f1 * f0;
                                    f2 = heapClassInst.heapFloat[r17 + numDefine128];
                                    f1 = f2 + f1;
                                    heapClassInst.heapFloat[r17 + numDefine128] = f1;
                                    f1 = heapClassInst.heapFloat[r17 + numDefine134];
                                    f1 = f1 * f0;
                                    f2 = heapClassInst.heapFloat[r11 + numDefine46];
                                    f3 = heapClassInst.heapFloat[r17 + numDefine136];
                                    f4 = heapClassInst.heapFloat[r17 + numDefine135];
                                    f1 = f2 * f1;
                                    f2 = heapClassInst.heapFloat[r17 + numDefine130];
                                    f5 = heapClassInst.heapFloat[r11 + numDefine48];
                                    f6 = heapClassInst.heapFloat[r11 + numDefine47];
                                    f1 = f2 + f1;
                                    f2 = f4 * f0;
                                    heapClassInst.heapFloat[r17 + numDefine130] = f1;
                                    f1 = f6 * f2;
                                    f2 = heapClassInst.heapFloat[r17 + numDefine131];
                                    f1 = f2 + f1;
                                    f0 = f3 * f0;
                                    heapClassInst.heapFloat[r17 + numDefine131] = f1;
                                    f0 = f5 * f0;
                                    f1 = heapClassInst.heapFloat[r17 + numDefine132];
                                    f0 = f1 + f0;
                                    heapClassInst.heapFloat[r17 + numDefine132] = f0;
                                  }
                                }
                                if (!(r15 === 0)) {
                                  r17 = r15 >> numDefine2;
                                  f0 = heapClassInst.heapFloat[r17 + numDefine84];
                                  f1 = 0;
                                  if (!(f0 === f1)) {
                                    f1 = heapClassInst.heapFloat[r11 + numDefine55];
                                    f1 = -f1;
                                    f2 = heapClassInst.heapFloat[r11 + numDefine38];
                                    f2 = f2 * f0;
                                    f3 = heapClassInst.heapFloat[r11 + numDefine39];
                                    f4 = heapClassInst.heapFloat[r11 + numDefine40];
                                    f2 = f2 * f1;
                                    f5 = heapClassInst.heapFloat[r17 + numDefine126];
                                    f6 = heapClassInst.heapFloat[r11 + numDefine50];
                                    f7 = heapClassInst.heapFloat[r11 + numDefine51];
                                    f8 = heapClassInst.heapFloat[r11 + numDefine52];
                                    f2 = f5 + f2;
                                    f3 = f3 * f0;
                                    heapClassInst.heapFloat[r17 + numDefine126] = f2;
                                    f2 = f3 * f1;
                                    f3 = heapClassInst.heapFloat[r17 + numDefine127];
                                    f2 = f3 + f2;
                                    f0 = f4 * f0;
                                    heapClassInst.heapFloat[r17 + numDefine127] = f2;
                                    f0 = f0 * f1;
                                    f2 = heapClassInst.heapFloat[r17 + numDefine128];
                                    f0 = f2 + f0;
                                    heapClassInst.heapFloat[r17 + numDefine128] = f0;
                                    f0 = heapClassInst.heapFloat[r17 + numDefine134];
                                    f0 = f0 * f1;
                                    f2 = heapClassInst.heapFloat[r17 + numDefine136];
                                    f3 = heapClassInst.heapFloat[r17 + numDefine135];
                                    f4 = heapClassInst.heapFloat[r17 + numDefine130];
                                    f0 = f0 * f6;
                                    f0 = f4 - f0;
                                    f3 = f3 * f1;
                                    heapClassInst.heapFloat[r17 + numDefine130] = f0;
                                    f0 = f3 * f7;
                                    f3 = heapClassInst.heapFloat[r17 + numDefine131];
                                    f0 = f3 - f0;
                                    f1 = f2 * f1;
                                    heapClassInst.heapFloat[r17 + numDefine131] = f0;
                                    f0 = f1 * f8;
                                    f1 = heapClassInst.heapFloat[r17 + numDefine132];
                                    f0 = f1 - f0;
                                    heapClassInst.heapFloat[r17 + numDefine132] = f0;
                                  }
                                }
                              }
                            }
                          }
                        }
                      } while (false);
                      r7 = (r7 + 1) | 0;
                      r4 = (r4 + numDefine276) | 0;
                    } else {
                      break repeat150;
                    }
                  }
                }
                r1 = heapClassInst.heap32[fp + numDefineNeg133];
                r1 = (r1 + -1) | 0;
                heapClassInst.heap32[fp + numDefineNeg133] = r1;
                r3 = heapClassInst.heap32[fp + numDefineNeg132];
                r3 = (r3 + numDefine4) | 0;
                heapClassInst.heap32[fp + numDefineNeg132] = r3;
                if (!(r1 !== 0)) {
                  break repeat132;
                }
              }
            }
          } while (false);
          r1 = heapClassInst.heap32[r2 + numDefine17];
          r3 = heapClassInst.heap32[r2 + numDefine2];
          r4 = heapClassInst.heap32[r2 + numDefine12];
          repeat307: do {
            if (!(r1 > r3)) {
              if (!(r1 >= r3)) {
                r5 = heapClassInst.heap32[r2 + numDefine18];
                if (!(r5 >= r3)) {
                  if (r3 !== 0) {
                    r5 = gNumAlignedAllocs;
                    r5 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r5];
                    r7 = r3 << numDefine2;
                    r6 = (r6 + 1) | 0;
                    r7 = r7 | numDefine3;
                    heapClassInst.heap32[r5] = r6;
                    r5 = (r7 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r5;
                    mallocNew(i7);
                    r5 = commonVariable.rg0;
                    if (r5 !== 0) {
                      r6 = 0;
                      r7 = (r5 + numDefine4) | 0;
                      r6 = (r6 - r7) | 0;
                      r6 = r6 & numDefine15;
                      r6 = (r5 + r6) | 0;
                      r7 = (r6 + numDefine4) | 0;
                      r6 = r6 >> numDefine2;
                      heapClassInst.heap32[r6] = r5;
                      r5 = r7;
                    }
                  } else {
                    r5 = 0;
                  }
                  r6 = (r0 + numDefine76) | 0;
                  if (r1 < 1) {
                    r7 = r6 >> numDefine2;
                    r8 = heapClassInst.heap32[r7];
                  } else {
                    r7 = 0;
                    repeat320: while (true) {
                      r8 = r6 >> numDefine2;
                      r8 = heapClassInst.heap32[r8];
                      r9 = r7 << numDefine2;
                      r10 = (r8 + r9) | 0;
                      r10 = r10 >> numDefine2;
                      r9 = (r5 + r9) | 0;
                      r10 = heapClassInst.heap32[r10];
                      r7 = (r7 + 1) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r9] = r10;
                      if (!(r1 !== r7)) {
                        break repeat320;
                      }
                    }
                    r6 = (r0 + numDefine76) | 0;
                  }
                  if (!(r8 === 0)) {
                    r7 = heapClassInst.heapU8[r0 + numDefine80];
                    if (!(r7 === 0)) {
                      r7 = gNumAlignedFree;
                      r7 = r7 >> numDefine2;
                      r9 = heapClassInst.heap32[r7];
                      r9 = (r9 + 1) | 0;
                      r8 = r8 >> numDefine2;
                      heapClassInst.heap32[r7] = r9;
                      r7 = heapClassInst.heap32[r8 + -1];
                      heapClassInst.heap32[g0] = r7;
                      free(i7);
                    }
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[r7] = 0;
                  }
                  r7 = 1;
                  r6 = r6 >> numDefine2;
                  heapClassInst.heap8[r0 + numDefine80] = r7;
                  heapClassInst.heap32[r6] = r5;
                  heapClassInst.heap32[r2 + numDefine18] = r3;
                  if (r1 >= r3) {
                    break repeat307;
                  }
                }
                while (true) {
                  r5 = r1 << numDefine2;
                  r6 = heapClassInst.heap32[r2 + numDefine19];
                  r5 = (r6 + r5) | 0;
                  r1 = (r1 + 1) | 0;
                  r5 = r5 >> numDefine2;
                  heapClassInst.heap32[r5] = 0;
                  if (!(r3 !== r1)) {
                    break repeat307;
                  }
                }
              }
            }
          } while (false);
          heapClassInst.heap32[r2 + numDefine17] = r3;
          r1 = heapClassInst.heap32[r2 + numDefine22];
          repeat333: do {
            if (!(r1 > r4)) {
              if (!(r1 >= r4)) {
                r5 = heapClassInst.heap32[r2 + numDefine23];
                if (!(r5 >= r4)) {
                  if (r4 !== 0) {
                    r5 = gNumAlignedAllocs;
                    r5 = r5 >> numDefine2;
                    r6 = heapClassInst.heap32[r5];
                    r7 = r4 << numDefine2;
                    r6 = (r6 + 1) | 0;
                    r7 = r7 | numDefine3;
                    heapClassInst.heap32[r5] = r6;
                    r5 = (r7 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r5;
                    mallocNew(i7);
                    r5 = commonVariable.rg0;
                    if (r5 !== 0) {
                      r6 = 0;
                      r7 = (r5 + numDefine4) | 0;
                      r6 = (r6 - r7) | 0;
                      r6 = r6 & numDefine15;
                      r6 = (r5 + r6) | 0;
                      r7 = (r6 + numDefine4) | 0;
                      r6 = r6 >> numDefine2;
                      heapClassInst.heap32[r6] = r5;
                      r5 = r7;
                    }
                  } else {
                    r5 = 0;
                  }
                  r6 = (r0 + numDefine96) | 0;
                  if (r1 < 1) {
                    r7 = r6 >> numDefine2;
                    r8 = heapClassInst.heap32[r7];
                  } else {
                    r7 = 0;
                    repeat346: while (true) {
                      r8 = r6 >> numDefine2;
                      r8 = heapClassInst.heap32[r8];
                      r9 = r7 << numDefine2;
                      r10 = (r8 + r9) | 0;
                      r10 = r10 >> numDefine2;
                      r9 = (r5 + r9) | 0;
                      r10 = heapClassInst.heap32[r10];
                      r7 = (r7 + 1) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r9] = r10;
                      if (!(r1 !== r7)) {
                        break repeat346;
                      }
                    }
                    r6 = (r0 + numDefine96) | 0;
                  }
                  if (!(r8 === 0)) {
                    r7 = heapClassInst.heapU8[r0 + numDefine100];
                    if (!(r7 === 0)) {
                      r7 = gNumAlignedFree;
                      r7 = r7 >> numDefine2;
                      r9 = heapClassInst.heap32[r7];
                      r9 = (r9 + 1) | 0;
                      r8 = r8 >> numDefine2;
                      heapClassInst.heap32[r7] = r9;
                      r7 = heapClassInst.heap32[r8 + -1];
                      heapClassInst.heap32[g0] = r7;
                      free(i7);
                    }
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[r7] = 0;
                  }
                  r7 = 1;
                  r6 = r6 >> numDefine2;
                  heapClassInst.heap8[r0 + numDefine100] = r7;
                  heapClassInst.heap32[r6] = r5;
                  heapClassInst.heap32[r2 + numDefine23] = r4;
                  if (r1 >= r4) {
                    break repeat333;
                  }
                }
                while (true) {
                  r0 = r1 << numDefine2;
                  r5 = heapClassInst.heap32[r2 + numDefine24];
                  r0 = (r5 + r0) | 0;
                  r1 = (r1 + 1) | 0;
                  r0 = r0 >> numDefine2;
                  heapClassInst.heap32[r0] = 0;
                  if (!(r4 !== r1)) {
                    break repeat333;
                  }
                }
              }
            }
          } while (false);
          heapClassInst.heap32[r2 + numDefine22] = r4;
          repeat359: do {
            if (!(r3 < 1)) {
              r0 = 0;
              while (true) {
                r1 = r0 << numDefine2;
                r5 = heapClassInst.heap32[r2 + numDefine19];
                r1 = (r5 + r1) | 0;
                r5 = (r0 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r1] = r0;
                r0 = r5;
                if (!(r3 !== r5)) {
                  break repeat359;
                }
              }
            }
          } while (false);
          if (r4 < 1) {
            break repeat1;
          } else {
            r0 = 0;
            while (true) {
              r1 = r0 << numDefine2;
              r3 = heapClassInst.heap32[r2 + numDefine24];
              r1 = (r3 + r1) | 0;
              r3 = (r0 + 1) | 0;
              r1 = r1 >> numDefine2;
              heapClassInst.heap32[r1] = r0;
              r0 = r3;
              if (!(r4 !== r3)) {
                break repeat1;
              }
            }
          }
        case numDefine78:
          r8 = twoEStr1157;
          r0 = twoEStr652;
          heapClassInst.heap32[g0] = r8;
          heapClassInst.heap32[g0 + 1] = r0;
          heapClassInst.heap32[g0 + numDefine2] = numDefine813;
          assertNew(i7);
          break;
        default:
          break;
      }
    }
  } while (false);
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat369: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat369;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  f0 = 0;
  commonVariable.fg0 = f0;
  return;
}

function zn35btSequentialImpulse(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr854;
  r1 = heapClassInst.heap32[fp + numDefine7];
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heap32[fp + numDefine5];
  r3 = heapClassInst.heap32[fp + numDefine6];
  r4 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r5 = heapClassInst.heap32[r4 + numDefine5];
  if (!(r5 < 1)) {
    r5 = 0;
    repeat3: while (true) {
      r6 = r0 >> numDefine2;
      r7 = heapClassInst.heap32[r4 + numDefine15];
      r8 = r7 & 1;
      if (r8 !== 0) {
        r8 = r5 & numDefine7;
        if (!(r8 !== 0)) {
          r7 = heapClassInst.heap32[r6 + numDefine2];
          r8 = heapClassInst.heap32[r6 + numDefine12];
          if (!(r7 < 1)) {
            r9 = 0;
            r7 = (r9 - r7) | 0;
            r9 = 1;
            repeat10: while (true) {
              r10 = heapClassInst.heap32[r6 + numDefine19];
              r11 = r9 << numDefine2;
              r11 = (r10 + r11) | 0;
              r11 = r11 >> numDefine2;
              r12 = heapClassInst.heap32[r6 + numDefine31];
              r13 = heapClassInst.heap32[r11 + -1];
              r12 = (r12 * numDefine64525) | 0;
              r12 = (r12 + numDefine04223) | 0;
              heapClassInst.heap32[r6 + numDefine31] = r12;
              if (uint(r9) < uint(numDefine65537)) {
                r14 = r12 >>> numDefine16;
                r12 = r14 ^ r12;
                if (uint(r9) < uint(numDefine257)) {
                  r14 = r12 >>> numDefine8;
                  r12 = r14 ^ r12;
                  if (uint(r9) < uint(numDefine17)) {
                    r14 = r12 >>> numDefine4;
                    r12 = r14 ^ r12;
                    if (uint(r9) < uint(numDefine5)) {
                      r14 = r12 >>> numDefine2;
                      r12 = r14 ^ r12;
                      if (uint(r9) < uint(numDefine3)) {
                        r14 = r12 >>> 1;
                        r12 = r14 ^ r12;
                      }
                    }
                  }
                }
              }
              r12 = Math.floor(uint(r12) % uint(r9));
              r12 = r12 << numDefine2;
              r10 = (r10 + r12) | 0;
              r10 = r10 >> numDefine2;
              r10 = heapClassInst.heap32[r10];
              heapClassInst.heap32[r11 + -1] = r10;
              r10 = heapClassInst.heap32[r6 + numDefine19];
              r10 = (r10 + r12) | 0;
              r9 = (r9 + 1) | 0;
              r10 = r10 >> numDefine2;
              heapClassInst.heap32[r10] = r13;
              r10 = (r7 + r9) | 0;
              if (!(r10 !== 1)) {
                break repeat10;
              }
            }
          }
          repeat20: do {
            if (!(r8 < 1)) {
              r7 = 0;
              r7 = (r7 - r8) | 0;
              r8 = 1;
              while (true) {
                r9 = heapClassInst.heap32[r6 + numDefine24];
                r10 = r8 << numDefine2;
                r10 = (r9 + r10) | 0;
                r10 = r10 >> numDefine2;
                r11 = heapClassInst.heap32[r6 + numDefine31];
                r12 = heapClassInst.heap32[r10 + -1];
                r11 = (r11 * numDefine64525) | 0;
                r11 = (r11 + numDefine04223) | 0;
                heapClassInst.heap32[r6 + numDefine31] = r11;
                if (uint(r8) < uint(numDefine65537)) {
                  r13 = r11 >>> numDefine16;
                  r11 = r13 ^ r11;
                  if (uint(r8) < uint(numDefine257)) {
                    r13 = r11 >>> numDefine8;
                    r11 = r13 ^ r11;
                    if (uint(r8) < uint(numDefine17)) {
                      r13 = r11 >>> numDefine4;
                      r11 = r13 ^ r11;
                      if (uint(r8) < uint(numDefine5)) {
                        r13 = r11 >>> numDefine2;
                        r11 = r13 ^ r11;
                        if (uint(r8) < uint(numDefine3)) {
                          r13 = r11 >>> 1;
                          r11 = r13 ^ r11;
                        }
                      }
                    }
                  }
                }
                r11 = Math.floor(uint(r11) % uint(r8));
                r11 = r11 << numDefine2;
                r9 = (r9 + r11) | 0;
                r9 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                heapClassInst.heap32[r10 + -1] = r9;
                r9 = heapClassInst.heap32[r6 + numDefine24];
                r9 = (r9 + r11) | 0;
                r8 = (r8 + 1) | 0;
                r9 = r9 >> numDefine2;
                heapClassInst.heap32[r9] = r12;
                r9 = (r7 + r8) | 0;
                if (!(r9 !== 1)) {
                  break repeat20;
                }
              }
            }
          } while (false);
          r7 = heapClassInst.heap32[r4 + numDefine15];
        }
      }
      r8 = heapClassInst.heap32[r6 + numDefine7];
      r7 = r7 & numDefine256;
      repeat33: do {
        if (r7 !== 0) {
          repeat35: do {
            if (!(r8 < 1)) {
              r7 = 0;
              r8 = r7;
              while (true) {
                r9 = (r8 * numDefine34) | 0;
                r10 = heapClassInst.heap32[r6 + numDefine9];
                r9 = r9 << numDefine2;
                r9 = (r10 + r9) | 0;
                r9 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r9 + numDefine27];
                r9 = heapClassInst.heap32[r9 + numDefine26];
                r10 = (r10 + r7) | 0;
                heapClassInst.heap32[g0] = r9;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                r8 = (r8 + 1) | 0;
                r7 = (r7 + numDefine136) | 0;
                zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                r9 = heapClassInst.heap32[r6 + numDefine7];
                if (!(r9 > r8)) {
                  break repeat35;
                }
              }
            }
          } while (false);
          repeat40: do {
            if (!(r3 < 1)) {
              r7 = r2;
              r8 = r3;
              while (true) {
                r9 = r7 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                r10 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r10];
                r11 = r11 >> numDefine2;
                r11 = heapClassInst.heap32[r11 + numDefine6];
                f0 = heapClassInst.heapFloat[r4 + numDefine3];
                r12 = heapClassInst.heap32[r10 + numDefine6];
                r10 = heapClassInst.heap32[r10 + numDefine5];
                heapClassInst.heap32[g0] = r9;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r12;
                heapClassInst.heapFloat[g0 + numDefine3] = f0;
                r8 = (r8 + -1) | 0;
                r7 = (r7 + numDefine4) | 0;
                functionTable[r11 >> numDefine2](i7);
                if (!(r8 !== 0)) {
                  break repeat40;
                }
              }
            }
          } while (false);
          r7 = heapClassInst.heap32[r6 + numDefine2];
          repeat45: do {
            if (!(r7 < 1)) {
              r8 = 0;
              while (true) {
                r9 = heapClassInst.heap32[r6 + numDefine19];
                r10 = r8 << numDefine2;
                r9 = (r9 + r10) | 0;
                r9 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                r9 = (r9 * numDefine136) | 0;
                r10 = heapClassInst.heap32[r6 + numDefine4];
                r9 = (r10 + r9) | 0;
                r10 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r10 + numDefine27];
                r10 = heapClassInst.heap32[r10 + numDefine26];
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                r8 = (r8 + 1) | 0;
                zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(i7);
                if (!(r7 !== r8)) {
                  break repeat45;
                }
              }
            }
          } while (false);
          r7 = heapClassInst.heap32[r6 + numDefine12];
          if (r7 < 1) {
            break repeat33;
          } else {
            r8 = 0;
            repeat51: while (true) {
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r10 = r8 << numDefine2;
              r9 = (r9 + r10) | 0;
              r9 = r9 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = heapClassInst.heap32[r6 + numDefine14];
              r9 = (r9 * numDefine136) | 0;
              r9 = (r10 + r9) | 0;
              r10 = r9 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + numDefine25];
              r12 = heapClassInst.heap32[r6 + numDefine4];
              r11 = (r11 * numDefine136) | 0;
              r11 = (r12 + r11) | 0;
              r11 = r11 >> numDefine2;
              f0 = heapClassInst.heapFloat[r11 + numDefine21];
              f1 = 0;
              if (!(f0 <= f1)) {
                f1 = heapClassInst.heapFloat[r10 + numDefine22];
                f0 = f1 * f0;
                f1 = -f0;
                heapClassInst.heapFloat[r10 + numDefine31] = f1;
                heapClassInst.heapFloat[r10 + numDefine32] = f0;
                r11 = heapClassInst.heap32[r10 + numDefine27];
                r10 = heapClassInst.heap32[r10 + numDefine26];
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
              }
              r8 = (r8 + 1) | 0;
              if (r7 === r8) {
                break repeat33;
              } else {
                continue repeat51;
              }
            }
          }
        } else {
          repeat57: do {
            if (!(r8 < 1)) {
              r8 = 0;
              r7 = r8;
              while (true) {
                r9 = (r7 * numDefine34) | 0;
                r10 = heapClassInst.heap32[r6 + numDefine9];
                r9 = r9 << numDefine2;
                r9 = (r10 + r9) | 0;
                r9 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r9 + numDefine27];
                r9 = heapClassInst.heap32[r9 + numDefine26];
                r10 = (r10 + r8) | 0;
                heapClassInst.heap32[g0] = r9;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                r7 = (r7 + 1) | 0;
                r8 = (r8 + numDefine136) | 0;
                zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
                r9 = heapClassInst.heap32[r6 + numDefine7];
                if (!(r9 > r7)) {
                  break repeat57;
                }
              }
            }
          } while (false);
          repeat62: do {
            if (!(r3 < 1)) {
              r7 = r2;
              r8 = r3;
              while (true) {
                r9 = r7 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                r10 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r10];
                r11 = r11 >> numDefine2;
                r11 = heapClassInst.heap32[r11 + numDefine6];
                f0 = heapClassInst.heapFloat[r4 + numDefine3];
                r12 = heapClassInst.heap32[r10 + numDefine6];
                r10 = heapClassInst.heap32[r10 + numDefine5];
                heapClassInst.heap32[g0] = r9;
                heapClassInst.heap32[g0 + 1] = r10;
                heapClassInst.heap32[g0 + numDefine2] = r12;
                heapClassInst.heapFloat[g0 + numDefine3] = f0;
                r8 = (r8 + -1) | 0;
                r7 = (r7 + numDefine4) | 0;
                functionTable[r11 >> numDefine2](i7);
                if (!(r8 !== 0)) {
                  break repeat62;
                }
              }
            }
          } while (false);
          r7 = heapClassInst.heap32[r6 + numDefine2];
          repeat67: do {
            if (!(r7 < 1)) {
              r8 = 0;
              while (true) {
                r9 = heapClassInst.heap32[r6 + numDefine19];
                r10 = r8 << numDefine2;
                r9 = (r9 + r10) | 0;
                r9 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                r9 = (r9 * numDefine136) | 0;
                r10 = heapClassInst.heap32[r6 + numDefine4];
                r9 = (r10 + r9) | 0;
                r10 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r10 + numDefine27];
                r10 = heapClassInst.heap32[r10 + numDefine26];
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                r8 = (r8 + 1) | 0;
                zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint(i7);
                if (!(r7 !== r8)) {
                  break repeat67;
                }
              }
            }
          } while (false);
          r7 = heapClassInst.heap32[r6 + numDefine12];
          if (!(r7 < 1)) {
            r8 = 0;
            while (true) {
              r9 = heapClassInst.heap32[r6 + numDefine24];
              r10 = r8 << numDefine2;
              r9 = (r9 + r10) | 0;
              r9 = r9 >> numDefine2;
              r9 = heapClassInst.heap32[r9];
              r10 = heapClassInst.heap32[r6 + numDefine14];
              r9 = (r9 * numDefine136) | 0;
              r9 = (r10 + r9) | 0;
              r10 = r9 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + numDefine25];
              r12 = heapClassInst.heap32[r6 + numDefine4];
              r11 = (r11 * numDefine136) | 0;
              r11 = (r12 + r11) | 0;
              r11 = r11 >> numDefine2;
              f0 = heapClassInst.heapFloat[r11 + numDefine21];
              f1 = 0;
              if (!(f0 <= f1)) {
                f1 = heapClassInst.heapFloat[r10 + numDefine22];
                f0 = f1 * f0;
                f1 = -f0;
                heapClassInst.heapFloat[r10 + numDefine31] = f1;
                heapClassInst.heapFloat[r10 + numDefine32] = f0;
                r11 = heapClassInst.heap32[r10 + numDefine27];
                r10 = heapClassInst.heap32[r10 + numDefine26];
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r11;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(i7);
              }
              r8 = (r8 + 1) | 0;
              if (!(r7 !== r8)) {
                break repeat33;
              }
            }
          }
        }
      } while (false);
      r5 = (r5 + 1) | 0;
      r6 = heapClassInst.heap32[r4 + numDefine5];
      if (r6 > r5) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r4 = heapClassInst.heap32[fp + 1];
  r5 = heapClassInst.heap32[fp + numDefine2];
  r6 = heapClassInst.heap32[fp + numDefine3];
  r7 = heapClassInst.heap32[fp + numDefine4];
  r8 = heapClassInst.heap32[fp + numDefine8];
  r9 = heapClassInst.heap32[fp + numDefine9];
  r10 = r0 >> numDefine2;
  r10 = heapClassInst.heap32[r10];
  r10 = r10 >> numDefine2;
  r10 = heapClassInst.heap32[r10 + numDefine6];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = r5;
  heapClassInst.heap32[g0 + numDefine3] = r6;
  heapClassInst.heap32[g0 + numDefine4] = r7;
  heapClassInst.heap32[g0 + numDefine5] = r2;
  heapClassInst.heap32[g0 + numDefine6] = r3;
  heapClassInst.heap32[g0 + numDefine7] = r1;
  heapClassInst.heap32[g0 + numDefine8] = r8;
  heapClassInst.heap32[g0 + numDefine9] = r9;
  r0 = zn15CProfileManager11CurrentNodeE;
  functionTable[r10 >> numDefine2](i7);
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat80: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat80;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  f0 = 0;
  commonVariable.fg0 = f0;
  return;
}

function zn35btSVector3P11(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg288;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine13];
  r3 = heapClassInst.heap32[r1 + numDefine12];
  r4 = heapClassInst.heap32[fp + 1];
  r5 = heapClassInst.heap32[fp + numDefine2];
  r6 = heapClassInst.heap32[fp + numDefine3];
  r7 = heapClassInst.heap32[fp + numDefine4];
  r8 = heapClassInst.heap32[fp + numDefine5];
  r9 = heapClassInst.heap32[fp + numDefine6];
  r10 = heapClassInst.heap32[fp + numDefine7];
  f0 = heapClassInst.heapFloat[fp + numDefine8];
  f1 = heapClassInst.heapFloat[fp + numDefine9];
  f2 = heapClassInst.heapFloat[fp + numDefine10];
  if (r2 === r3) {
    r11 = 1;
    r12 = r3 << 1;
    r12 = r3 === 0 ? r11 : r12;
    if (r2 >= r12) {
      label = 1;
    } else {
      if (r12 !== 0) {
        r2 = gNumAlignedAllocs;
        r2 = r2 >> numDefine2;
        r13 = heapClassInst.heap32[r2];
        r14 = (r12 * numDefine136) | 0;
        r13 = (r13 + 1) | 0;
        r14 = r14 | numDefine3;
        heapClassInst.heap32[r2] = r13;
        r2 = (r14 + numDefine16) | 0;
        heapClassInst.heap32[g0] = r2;
        mallocNew(i7);
        r13 = commonVariable.rg0;
        if (r13 !== 0) {
          r2 = 0;
          r14 = (r13 + numDefine4) | 0;
          r2 = (r2 - r14) | 0;
          r2 = r2 & numDefine15;
          r2 = (r13 + r2) | 0;
          r14 = (r2 + numDefine4) | 0;
          r2 = r2 >> numDefine2;
          heapClassInst.heap32[r2] = r13;
          r13 = r14;
        }
      } else {
        r13 = 0;
      }
      r14 = (r0 + numDefine56) | 0;
      if (r3 < 1) {
        r2 = r14 >> numDefine2;
        r16 = heapClassInst.heap32[r2];
      } else {
        r2 = 0;
        r15 = r3;
        repeat12: while (true) {
          r16 = r14 >> numDefine2;
          r16 = heapClassInst.heap32[r16];
          r17 = (r13 + r2) | 0;
          r18 = (r16 + r2) | 0;
          heapClassInst.heap32[g0] = r17;
          heapClassInst.heap32[g0 + 1] = r18;
          heapClassInst.heap32[g0 + numDefine2] = numDefine136;
          r15 = (r15 + -1) | 0;
          r2 = (r2 + numDefine136) | 0;
          memcpy(i7);
          if (!(r15 !== 0)) {
            break repeat12;
          }
        }
        r14 = (r0 + numDefine56) | 0;
      }
      if (r16 !== 0) {
        r2 = heapClassInst.heapU8[r0 + numDefine60];
        if (r2 !== 0) {
          r2 = gNumAlignedFree;
          r2 = r2 >> numDefine2;
          r15 = heapClassInst.heap32[r2];
          r15 = (r15 + 1) | 0;
          r16 = r16 >> numDefine2;
          heapClassInst.heap32[r2] = r15;
          r2 = heapClassInst.heap32[r16 + -1];
          heapClassInst.heap32[g0] = r2;
          free(i7);
          r2 = heapClassInst.heap32[r1 + numDefine12];
        } else {
          r2 = r3;
        }
        r15 = r14 >> numDefine2;
        heapClassInst.heap32[r15] = 0;
      } else {
        r2 = r3;
      }
      r14 = r14 >> numDefine2;
      heapClassInst.heap8[r0 + numDefine60] = r11;
      heapClassInst.heap32[r14] = r13;
      heapClassInst.heap32[r1 + numDefine13] = r12;
      label = numDefine19;
    }
  } else {
    label = 1;
  }
  if (label === 1) {
    r2 = r3;
  }
  r0 = (r2 + 1) | 0;
  heapClassInst.heap32[r1 + numDefine12] = r0;
  r0 = heapClassInst.heap32[r1 + numDefine14];
  r1 = (r3 * numDefine136) | 0;
  r0 = (r0 + r1) | 0;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine25] = r5;
  r1 = heapClassInst.heapU8[r9 + numDefine232];
  r1 = r1 & numDefine2;
  if (!(r1 !== 0)) {
    r9 = 0;
  }
  r1 = heapClassInst.heapU8[r10 + numDefine232];
  r1 = r1 & numDefine2;
  if (!(r1 !== 0)) {
    r10 = 0;
  }
  r1 = r4 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine4] = heapClassInst.heap32[r1];
  heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r0 + numDefine6] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r0 + numDefine7] = heapClassInst.heap32[r1 + numDefine3];
  if (r9 === 0) {
    r2 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    r3 = heapClassInst.heapU8[r2];
    if (!(r3 !== 0)) {
      r3 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r4 + numDefine41] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine42] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine43] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine44] = 0;
      heapClassInst.heap32[r4 + numDefine45] = 0;
      heapClassInst.heap32[r4 + numDefine46] = numDefine44395;
      heapClassInst.heap32[r4 + numDefine47] = 0;
      heapClassInst.heap32[r4 + numDefine48] = 0;
      heapClassInst.heap32[r4 + numDefine49] = 0;
      heapClassInst.heap32[r4 + numDefine50] = 0;
      heapClassInst.heap32[r4 + numDefine51] = 1;
      heapClassInst.heap32[r4 + numDefine52] = -1;
      heapClassInst.heap32[r4 + numDefine53] = -1;
      heapClassInst.heap32[r4 + numDefine54] = 1;
      heapClassInst.heap32[r4 + numDefine55] = 0;
      heapClassInst.heap32[r4 + numDefine56] = numDefine64608;
      heapClassInst.heap32[r4 + numDefine57] = 0;
      heapClassInst.heap32[r4 + numDefine58] = 1;
      heapClassInst.heap32[r4 + numDefine59] = 0;
      heapClassInst.heap32[r4 + numDefine60] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine61] = 0;
      heapClassInst.heap32[r4 + numDefine62] = 0;
      heapClassInst.heap32[r4 + numDefine63] = 0;
      heapClassInst.heap32[r4 + 1] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine2] = 0;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      heapClassInst.heap32[r4 + numDefine4] = 0;
      heapClassInst.heap32[r4 + numDefine5] = 0;
      heapClassInst.heap32[r4 + numDefine6] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine7] = 0;
      heapClassInst.heap32[r4 + numDefine8] = 0;
      heapClassInst.heap32[r4 + numDefine9] = 0;
      heapClassInst.heap32[r4 + numDefine10] = 0;
      heapClassInst.heap32[r4 + numDefine11] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine12] = 0;
      heapClassInst.heap32[r4 + numDefine13] = 0;
      heapClassInst.heap32[r4 + numDefine14] = 0;
      r5 = ztv11btRigidBody;
      heapClassInst.heap32[r4 + numDefine15] = 0;
      r5 = (r5 + numDefine8) | 0;
      heapClassInst.heap32[r4 + numDefine16] = 0;
      r11 = 1;
      heapClassInst.heap32[r4] = r5;
      heapClassInst.heap8[r3 + numDefine492] = r11;
      heapClassInst.heap32[r4 + numDefine122] = 0;
      heapClassInst.heap32[r4 + numDefine120] = 0;
      r5 = sp + numDefineNeg272;
      heapClassInst.heap32[r4 + numDefine121] = 0;
      r4 = r5 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg68] = 0;
      heapClassInst.heap32[r4 + 1] = 0;
      heapClassInst.heap32[r4 + numDefine18] = 0;
      heapClassInst.heap32[r4 + numDefine19] = 0;
      heapClassInst.heap32[r4 + numDefine20] = 0;
      heapClassInst.heap32[r4 + numDefine21] = 0;
      heapClassInst.heap32[r4 + numDefine22] = 0;
      heapClassInst.heap32[r4 + numDefine23] = 0;
      heapClassInst.heap32[r4 + numDefine24] = 0;
      heapClassInst.heap32[r4 + numDefine25] = numDefine64608;
      heapClassInst.heap32[r4 + numDefine26] = 0;
      heapClassInst.heap32[r4 + numDefine27] = numDefine97773;
      r12 = 0;
      heapClassInst.heap32[r4 + numDefine28] = numDefine53216;
      heapClassInst.heap8[sp + numDefineNeg156] = r12;
      heapClassInst.heap32[r4 + numDefine30] = numDefine93162;
      heapClassInst.heap32[r4 + numDefine31] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine32] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine33] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      heapClassInst.heap32[r4 + numDefine4] = 0;
      heapClassInst.heap32[r4 + numDefine5] = 0;
      heapClassInst.heap32[r4 + numDefine6] = 0;
      heapClassInst.heap32[r4 + numDefine7] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine8] = 0;
      heapClassInst.heap32[r4 + numDefine9] = 0;
      heapClassInst.heap32[r4 + numDefine10] = 0;
      heapClassInst.heap32[r4 + numDefine11] = 0;
      heapClassInst.heap32[r4 + numDefine12] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine13] = 0;
      heapClassInst.heap32[r4 + numDefine14] = 0;
      heapClassInst.heap32[r4 + numDefine15] = 0;
      heapClassInst.heap32[r4 + numDefine16] = 0;
      heapClassInst.heap32[r4 + numDefine17] = 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r5;
      zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
      heapClassInst.heap8[r2] = r11;
    }
    r2 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    r3 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r3 + numDefine51];
    r4 = r4 | 1;
    heapClassInst.heap32[r3 + numDefine51] = r4;
    heapClassInst.heap32[r3 + numDefine84] = 0;
    f3 = 0;
    f4 = heapClassInst.heapFloat[r3 + numDefine95];
    f5 = heapClassInst.heapFloat[r3 + numDefine94];
    f6 = heapClassInst.heapFloat[r3 + numDefine93];
    f6 = f6 * f3;
    f5 = f5 * f3;
    heapClassInst.heapFloat[r3 + numDefine89] = f6;
    f4 = f4 * f3;
    heapClassInst.heapFloat[r3 + numDefine90] = f5;
    heapClassInst.heapFloat[r3 + numDefine91] = f4;
    heapClassInst.heap32[r3 + numDefine92] = 0;
    heapClassInst.heap32[r3 + numDefine97] = 0;
    heapClassInst.heap32[r3 + numDefine98] = 0;
    heapClassInst.heap32[r3 + numDefine99] = 0;
    heapClassInst.heap32[r3 + numDefine100] = 0;
    f4 = heapClassInst.heapFloat[r3 + numDefine87];
    f5 = heapClassInst.heapFloat[r3 + numDefine86];
    f6 = heapClassInst.heapFloat[r3 + numDefine85];
    f6 = f6 * f3;
    f5 = f5 * f3;
    heapClassInst.heapFloat[r3 + numDefine138] = f6;
    f3 = f4 * f3;
    heapClassInst.heapFloat[r3 + numDefine139] = f5;
    heapClassInst.heapFloat[r3 + numDefine140] = f3;
    heapClassInst.heap32[r3 + numDefine141] = 0;
  } else {
    r2 = r9;
  }
  heapClassInst.heap32[r0 + numDefine26] = r2;
  if (r10 === 0) {
    r2 = zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    r3 = heapClassInst.heapU8[r2];
    if (!(r3 !== 0)) {
      r3 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r4 + numDefine41] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine42] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine43] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine44] = 0;
      heapClassInst.heap32[r4 + numDefine45] = 0;
      heapClassInst.heap32[r4 + numDefine46] = numDefine44395;
      heapClassInst.heap32[r4 + numDefine47] = 0;
      heapClassInst.heap32[r4 + numDefine48] = 0;
      heapClassInst.heap32[r4 + numDefine49] = 0;
      heapClassInst.heap32[r4 + numDefine50] = 0;
      heapClassInst.heap32[r4 + numDefine51] = 1;
      heapClassInst.heap32[r4 + numDefine52] = -1;
      heapClassInst.heap32[r4 + numDefine53] = -1;
      heapClassInst.heap32[r4 + numDefine54] = 1;
      heapClassInst.heap32[r4 + numDefine55] = 0;
      heapClassInst.heap32[r4 + numDefine56] = numDefine64608;
      heapClassInst.heap32[r4 + numDefine57] = 0;
      heapClassInst.heap32[r4 + numDefine58] = 1;
      heapClassInst.heap32[r4 + numDefine59] = 0;
      heapClassInst.heap32[r4 + numDefine60] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine61] = 0;
      heapClassInst.heap32[r4 + numDefine62] = 0;
      heapClassInst.heap32[r4 + numDefine63] = 0;
      heapClassInst.heap32[r4 + 1] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine2] = 0;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      heapClassInst.heap32[r4 + numDefine4] = 0;
      heapClassInst.heap32[r4 + numDefine5] = 0;
      heapClassInst.heap32[r4 + numDefine6] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine7] = 0;
      heapClassInst.heap32[r4 + numDefine8] = 0;
      heapClassInst.heap32[r4 + numDefine9] = 0;
      heapClassInst.heap32[r4 + numDefine10] = 0;
      heapClassInst.heap32[r4 + numDefine11] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine12] = 0;
      heapClassInst.heap32[r4 + numDefine13] = 0;
      heapClassInst.heap32[r4 + numDefine14] = 0;
      r5 = ztv11btRigidBody;
      heapClassInst.heap32[r4 + numDefine15] = 0;
      r5 = (r5 + numDefine8) | 0;
      heapClassInst.heap32[r4 + numDefine16] = 0;
      r11 = 1;
      heapClassInst.heap32[r4] = r5;
      heapClassInst.heap8[r3 + numDefine492] = r11;
      heapClassInst.heap32[r4 + numDefine122] = 0;
      heapClassInst.heap32[r4 + numDefine120] = 0;
      r5 = sp + numDefineNeg136;
      heapClassInst.heap32[r4 + numDefine121] = 0;
      r4 = r5 >> numDefine2;
      heapClassInst.heap32[fp + numDefineNeg34] = 0;
      heapClassInst.heap32[r4 + 1] = 0;
      heapClassInst.heap32[r4 + numDefine18] = 0;
      heapClassInst.heap32[r4 + numDefine19] = 0;
      heapClassInst.heap32[r4 + numDefine20] = 0;
      heapClassInst.heap32[r4 + numDefine21] = 0;
      heapClassInst.heap32[r4 + numDefine22] = 0;
      heapClassInst.heap32[r4 + numDefine23] = 0;
      heapClassInst.heap32[r4 + numDefine24] = 0;
      heapClassInst.heap32[r4 + numDefine25] = numDefine64608;
      heapClassInst.heap32[r4 + numDefine26] = 0;
      heapClassInst.heap32[r4 + numDefine27] = numDefine97773;
      r12 = 0;
      heapClassInst.heap32[r4 + numDefine28] = numDefine53216;
      heapClassInst.heap8[sp + numDefineNeg20] = r12;
      heapClassInst.heap32[r4 + numDefine30] = numDefine93162;
      heapClassInst.heap32[r4 + numDefine31] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine32] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine33] = numDefine81770;
      heapClassInst.heap32[r4 + numDefine2] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine3] = 0;
      heapClassInst.heap32[r4 + numDefine4] = 0;
      heapClassInst.heap32[r4 + numDefine5] = 0;
      heapClassInst.heap32[r4 + numDefine6] = 0;
      heapClassInst.heap32[r4 + numDefine7] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine8] = 0;
      heapClassInst.heap32[r4 + numDefine9] = 0;
      heapClassInst.heap32[r4 + numDefine10] = 0;
      heapClassInst.heap32[r4 + numDefine11] = 0;
      heapClassInst.heap32[r4 + numDefine12] = numDefine53216;
      heapClassInst.heap32[r4 + numDefine13] = 0;
      heapClassInst.heap32[r4 + numDefine14] = 0;
      heapClassInst.heap32[r4 + numDefine15] = 0;
      heapClassInst.heap32[r4 + numDefine16] = 0;
      heapClassInst.heap32[r4 + numDefine17] = 0;
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r5;
      zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE(i7);
      heapClassInst.heap8[r2] = r11;
    }
    r2 = zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed;
    r3 = r2 >> numDefine2;
    r4 = heapClassInst.heap32[r3 + numDefine51];
    r4 = r4 | 1;
    heapClassInst.heap32[r3 + numDefine51] = r4;
    heapClassInst.heap32[r3 + numDefine84] = 0;
    f3 = 0;
    f4 = heapClassInst.heapFloat[r3 + numDefine95];
    f5 = heapClassInst.heapFloat[r3 + numDefine94];
    f6 = heapClassInst.heapFloat[r3 + numDefine93];
    f6 = f6 * f3;
    f5 = f5 * f3;
    heapClassInst.heapFloat[r3 + numDefine89] = f6;
    f4 = f4 * f3;
    heapClassInst.heapFloat[r3 + numDefine90] = f5;
    heapClassInst.heapFloat[r3 + numDefine91] = f4;
    heapClassInst.heap32[r3 + numDefine92] = 0;
    heapClassInst.heap32[r3 + numDefine97] = 0;
    heapClassInst.heap32[r3 + numDefine98] = 0;
    heapClassInst.heap32[r3 + numDefine99] = 0;
    heapClassInst.heap32[r3 + numDefine100] = 0;
    f4 = heapClassInst.heapFloat[r3 + numDefine87];
    f5 = heapClassInst.heapFloat[r3 + numDefine86];
    f6 = heapClassInst.heapFloat[r3 + numDefine85];
    f6 = f6 * f3;
    f5 = f5 * f3;
    heapClassInst.heapFloat[r3 + numDefine138] = f6;
    f3 = f4 * f3;
    heapClassInst.heapFloat[r3 + numDefine139] = f5;
    heapClassInst.heapFloat[r3 + numDefine140] = f3;
    heapClassInst.heap32[r3 + numDefine141] = 0;
  } else {
    r2 = r10;
  }
  r3 = r6 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine27] = r2;
  heapClassInst.heap32[r0 + numDefine22] = heapClassInst.heap32[r3 + numDefine21];
  heapClassInst.heap32[r0 + numDefine28] = 0;
  heapClassInst.heap32[r0 + numDefine21] = 0;
  heapClassInst.heap32[r0 + numDefine20] = 0;
  r2 = r7 >> numDefine2;
  f3 = heapClassInst.heapFloat[r0 + numDefine5];
  f4 = heapClassInst.heapFloat[r2 + numDefine2];
  f5 = heapClassInst.heapFloat[r0 + numDefine6];
  f6 = heapClassInst.heapFloat[r2 + 1];
  f7 = heapClassInst.heapFloat[r0 + numDefine4];
  f8 = heapClassInst.heapFloat[r2];
  f9 = f6 * f5;
  f10 = f4 * f3;
  f9 = f9 - f10;
  f4 = f4 * f7;
  f10 = f8 * f5;
  f4 = f4 - f10;
  heapClassInst.heapFloat[r0] = f9;
  f8 = f8 * f3;
  f6 = f6 * f7;
  f6 = f8 - f6;
  heapClassInst.heapFloat[r0 + 1] = f4;
  heapClassInst.heapFloat[r0 + numDefine2] = f6;
  heapClassInst.heap32[r0 + numDefine3] = 0;
  if (r9 === 0) {
    heapClassInst.heap32[r0 + numDefine12] = 0;
    heapClassInst.heap32[r0 + numDefine13] = 0;
    f10 = 0;
    heapClassInst.heap32[r0 + numDefine14] = 0;
    heapClassInst.heap32[r0 + numDefine15] = 0;
    f11 = f10;
    f8 = f10;
  } else {
    r3 = r9 >> numDefine2;
    f8 = heapClassInst.heapFloat[r3 + numDefine64];
    f10 = heapClassInst.heapFloat[r3 + numDefine65];
    f11 = heapClassInst.heapFloat[r3 + numDefine68];
    f12 = heapClassInst.heapFloat[r3 + numDefine69];
    f8 = f8 * f9;
    f10 = f10 * f4;
    f13 = heapClassInst.heapFloat[r3 + numDefine66];
    f14 = heapClassInst.heapFloat[r3 + numDefine72];
    f15 = heapClassInst.heapFloat[r3 + numDefine73];
    f16 = heapClassInst.heapFloat[r3 + numDefine70];
    f11 = f11 * f9;
    f12 = f12 * f4;
    f8 = f8 + f10;
    f10 = f13 * f6;
    f13 = heapClassInst.heapFloat[r3 + numDefine74];
    f14 = f14 * f9;
    f15 = f15 * f4;
    f11 = f11 + f12;
    f12 = f16 * f6;
    f8 = f8 + f10;
    f10 = heapClassInst.heapFloat[r3 + numDefine134];
    f16 = heapClassInst.heapFloat[r3 + numDefine136];
    f17 = heapClassInst.heapFloat[r3 + numDefine135];
    f11 = f11 + f12;
    f8 = f8 * f10;
    f10 = f14 + f15;
    f12 = f13 * f6;
    f10 = f10 + f12;
    f11 = f11 * f17;
    heapClassInst.heapFloat[r0 + numDefine12] = f8;
    f10 = f10 * f16;
    heapClassInst.heapFloat[r0 + numDefine13] = f11;
    heapClassInst.heapFloat[r0 + numDefine14] = f10;
    heapClassInst.heap32[r0 + numDefine15] = 0;
  }
  r3 = r8 >> numDefine2;
  f12 = heapClassInst.heapFloat[r3 + numDefine2];
  f13 = heapClassInst.heapFloat[r3 + 1];
  f14 = heapClassInst.heapFloat[r3];
  f15 = f12 * f3;
  f16 = f13 * f5;
  f15 = f15 - f16;
  f16 = f14 * f5;
  f12 = f12 * f7;
  f12 = f16 - f12;
  heapClassInst.heapFloat[r0 + numDefine8] = f15;
  f13 = f13 * f7;
  f14 = f14 * f3;
  f13 = f13 - f14;
  heapClassInst.heapFloat[r0 + numDefine9] = f12;
  heapClassInst.heapFloat[r0 + numDefine10] = f13;
  heapClassInst.heap32[r0 + numDefine11] = 0;
  if (r10 === 0) {
    heapClassInst.heap32[r0 + numDefine16] = 0;
    heapClassInst.heap32[r0 + numDefine17] = 0;
    f14 = 0;
    heapClassInst.heap32[r0 + numDefine18] = 0;
    heapClassInst.heap32[r0 + numDefine19] = 0;
    f17 = f14;
    f16 = f14;
  } else {
    r4 = r10 >> numDefine2;
    f14 = heapClassInst.heapFloat[r4 + numDefine64];
    f16 = heapClassInst.heapFloat[r4 + numDefine65];
    f17 = heapClassInst.heapFloat[r4 + numDefine68];
    f18 = heapClassInst.heapFloat[r4 + numDefine69];
    f14 = f14 * f15;
    f16 = f16 * f12;
    f19 = heapClassInst.heapFloat[r4 + numDefine66];
    f20 = heapClassInst.heapFloat[r4 + numDefine72];
    f21 = heapClassInst.heapFloat[r4 + numDefine73];
    f22 = heapClassInst.heapFloat[r4 + numDefine70];
    f17 = f17 * f15;
    f18 = f18 * f12;
    f14 = f14 + f16;
    f16 = f19 * f13;
    f19 = heapClassInst.heapFloat[r4 + numDefine74];
    f20 = f20 * f15;
    f21 = f21 * f12;
    f17 = f17 + f18;
    f18 = f22 * f13;
    f14 = f14 + f16;
    f16 = heapClassInst.heapFloat[r4 + numDefine134];
    f22 = heapClassInst.heapFloat[r4 + numDefine136];
    f23 = heapClassInst.heapFloat[r4 + numDefine135];
    f17 = f17 + f18;
    f14 = f14 * f16;
    f16 = f20 + f21;
    f18 = f19 * f13;
    f16 = f16 + f18;
    f17 = f17 * f23;
    heapClassInst.heapFloat[r0 + numDefine16] = f14;
    f16 = f16 * f22;
    heapClassInst.heapFloat[r0 + numDefine17] = f17;
    heapClassInst.heapFloat[r0 + numDefine18] = f16;
    heapClassInst.heap32[r0 + numDefine19] = 0;
  }
  if (r9 !== 0) {
    f18 = heapClassInst.heapFloat[r2 + 1];
    f19 = heapClassInst.heapFloat[r2 + numDefine2];
    f20 = heapClassInst.heapFloat[r2];
    f21 = f11 * f19;
    f22 = f10 * f18;
    f10 = f10 * f20;
    f19 = f8 * f19;
    f23 = heapClassInst.heapFloat[r1];
    f21 = f21 - f22;
    f22 = heapClassInst.heapFloat[r1 + 1];
    f10 = f10 - f19;
    f8 = f8 * f18;
    f11 = f11 * f20;
    f18 = f23 * f21;
    f10 = f22 * f10;
    f19 = heapClassInst.heapFloat[r1 + numDefine2];
    f8 = f8 - f11;
    r2 = r9 >> numDefine2;
    f10 = f18 + f10;
    f8 = f19 * f8;
    f11 = heapClassInst.heapFloat[r2 + numDefine84];
    f8 = f10 + f8;
    f8 = f11 + f8;
  } else {
    f8 = 0;
  }
  if (r10 !== 0) {
    f10 = heapClassInst.heapFloat[r3 + numDefine2];
    f11 = heapClassInst.heapFloat[r3];
    f18 = heapClassInst.heapFloat[r3 + 1];
    f19 = f18 * f16;
    f20 = f10 * f17;
    f10 = f10 * f14;
    f16 = f11 * f16;
    f21 = heapClassInst.heapFloat[r1];
    f19 = f19 - f20;
    f20 = heapClassInst.heapFloat[r1 + 1];
    f10 = f10 - f16;
    f11 = f11 * f17;
    f14 = f18 * f14;
    f16 = f21 * f19;
    f10 = f20 * f10;
    f17 = heapClassInst.heapFloat[r1 + numDefine2];
    f14 = f11 - f14;
    r1 = r10 >> numDefine2;
    f10 = f16 + f10;
    f14 = f17 * f14;
    f11 = heapClassInst.heapFloat[r1 + numDefine84];
    f14 = f10 + f14;
    f14 = f11 + f14;
  } else {
    f14 = 0;
  }
  f8 = f8 + f14;
  f0 = f0 / f8;
  heapClassInst.heapFloat[r0 + numDefine23] = f0;
  if (r9 !== 0) {
    r1 = r9 >> numDefine2;
    f8 = heapClassInst.heapFloat[r1 + numDefine76];
    f10 = heapClassInst.heapFloat[r1 + numDefine77];
    f8 = f7 * f8;
    f10 = f3 * f10;
    f11 = heapClassInst.heapFloat[r1 + numDefine78];
    f8 = f8 + f10;
    f10 = f5 * f11;
    f10 = f8 + f10;
    f14 = heapClassInst.heapFloat[r1 + numDefine80];
    f11 = heapClassInst.heapFloat[r1 + numDefine81];
    f8 = heapClassInst.heapFloat[r1 + numDefine82];
  } else {
    f8 = 0;
    f10 = f7 * f8;
    f11 = f3 * f8;
    f10 = f10 + f11;
    f11 = f5 * f8;
    f10 = f10 + f11;
    f11 = f8;
    f14 = f8;
  }
  f9 = f9 * f14;
  f4 = f4 * f11;
  f4 = f9 + f4;
  f6 = f6 * f8;
  f4 = f4 + f6;
  f4 = f10 + f4;
  if (r10 !== 0) {
    r1 = r10 >> numDefine2;
    f6 = heapClassInst.heapFloat[r1 + numDefine80];
    f8 = heapClassInst.heapFloat[r1 + numDefine81];
    f6 = f15 * f6;
    f12 = f12 * f8;
    f15 = heapClassInst.heapFloat[r1 + numDefine82];
    f6 = f6 + f12;
    f12 = f13 * f15;
    f12 = f6 + f12;
    f15 = heapClassInst.heapFloat[r1 + numDefine76];
    f13 = heapClassInst.heapFloat[r1 + numDefine77];
    f6 = heapClassInst.heapFloat[r1 + numDefine78];
  } else {
    f6 = 0;
    f15 = f15 * f6;
    f12 = f12 * f6;
    f12 = f15 + f12;
    f13 = f13 * f6;
    f12 = f12 + f13;
    f13 = f6;
    f15 = f6;
  }
  f7 = f7 * f15;
  f3 = f3 * f13;
  f3 = f7 + f3;
  f5 = f5 * f6;
  f3 = f3 + f5;
  f3 = f12 - f3;
  f3 = f4 + f3;
  f1 = f1 - f3;
  f0 = f0 * f1;
  heapClassInst.heapFloat[r0 + numDefine29] = f0;
  heapClassInst.heapFloat[r0 + numDefine30] = f2;
  heapClassInst.heap32[r0 + numDefine31] = 0;
  heapClassInst.heap32[r0 + numDefine32] = numDefine54297;
  return;
}

function zn23btDiscreteDynamicsWorld11setNumTasksEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn23btDiscreteDynamicsWorld14updateVehiclesEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr289;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r2 = heapClassInst.heap32[r0 + numDefine63];
  if (!(r2 < 1)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    r2 = 0;
    repeat3: while (true) {
      r3 = heapClassInst.heap32[r0 + numDefine65];
      r4 = r2 << numDefine2;
      r3 = (r3 + r4) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine2];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heapFloat[g0 + numDefine2] = f0;
      r2 = (r2 + 1) | 0;
      functionTable[r4 >> numDefine2](i7);
      r3 = heapClassInst.heap32[r0 + numDefine63];
      if (r3 > r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat6: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat6;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn15btDynamicsWorld13addConstraintEP17btTypedConstraintb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btDynamicsWorld16removeConstraintEP17btTypedConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function znk15btDynamicsWorld17getNumConstraintsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btDynamicsWorld13getConstraintEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function znk15btDynamicsWorld13getConstraintEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = 0;
  commonVariable.rg0 = r0;
  return;
}

function zn15btDynamicsWorld10addVehicleEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btDynamicsWorld13removeVehicleEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btDynamicsWorld12addCharacterEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function zn15btDynamicsWorld15removeCharacterEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  return;
}

function znk23btDiscreteDynamicsWorld12getWorldTypeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine2;
  commonVariable.rg0 = r0;
  return;
}

function znk23btDiscreteDynamicsWorld10getGravityEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r0] = heapClassInst.heap32[r1 + numDefine56];
  heapClassInst.heap32[r0 + 1] = heapClassInst.heap32[r1 + numDefine57];
  heapClassInst.heap32[r0 + numDefine2] = heapClassInst.heap32[r1 + numDefine58];
  heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[r1 + numDefine59];
  return;
}

function zn23btDiscreteDynamicsWorld10addVehicleEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine15];
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function zn23btDiscreteDynamicsWorld13removeVehicleEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine16];
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function zn23btDiscreteDynamicsWorld12addCharacterEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine15];
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function zn23btDiscreteDynamicsWorld15removeCharacterEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine16];
  r2 = heapClassInst.heap32[fp + 1];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function zn34btClosestNotMeConvexResultCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  return;
}

function zn34btClosestNotMeConvexResultCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function znk34btClosestNotMeConvexResultCallback14needsCollisionEP17btBroadphaseProxy(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r1 >> numDefine2;
  r3 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r4 = heapClassInst.heap32[r3 + numDefine20];
  if (r2 !== r4) {
    r5 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
    r6 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
    r5 = r5 & r6;
    r5 = r5 & numDefine65535;
    if (r5 === 0) {
      label = 1;
    } else {
      r5 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
      r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
      r0 = r5 & r0;
      r0 = r0 & numDefine65535;
      if (r0 === 0) {
        label = 1;
      } else {
        r0 = heapClassInst.heap32[r3 + numDefine23];
        r5 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5 + numDefine7];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        functionTable[r5 >> numDefine2](i7);
        r0 = commonVariable.rg0;
        if (r0 !== 0) {
          r0 = sp + numDefineNeg24;
          r2 = 1;
          r4 = r0 >> numDefine2;
          heapClassInst.heap8[sp + numDefineNeg8] = r2;
          heapClassInst.heap32[r4 + numDefine3] = 0;
          heapClassInst.heap32[r4 + 1] = 0;
          heapClassInst.heap32[r4 + numDefine2] = 0;
          r5 = heapClassInst.heap32[r3 + numDefine22];
          r6 = r5 >> numDefine2;
          r6 = heapClassInst.heap32[r6];
          r3 = heapClassInst.heap32[r3 + numDefine20];
          r6 = r6 >> numDefine2;
          r3 = r3 >> numDefine2;
          r6 = heapClassInst.heap32[r6 + numDefine13];
          r3 = heapClassInst.heap32[r3 + numDefine47];
          heapClassInst.heap32[g0] = r5;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = r1;
          functionTable[r6 >> numDefine2](i7);
          r1 = commonVariable.rg0;
          repeat7: do {
            if (!(r1 === 0)) {
              r1 = r1 >> numDefine2;
              r3 = heapClassInst.heap32[r1 + numDefine2];
              if (!(r3 === 0)) {
                r3 = heapClassInst.heap32[r4 + 1];
                if (!(r3 > -1)) {
                  r5 = heapClassInst.heap32[r4 + numDefine2];
                  if (r5 < 0) {
                    r5 = heapClassInst.heap32[r4 + numDefine3];
                    if (!(r5 === 0)) {
                      r6 = heapClassInst.heapU8[sp + numDefineNeg8];
                      if (!(r6 === 0)) {
                        r6 = gNumAlignedFree;
                        r6 = r6 >> numDefine2;
                        r7 = heapClassInst.heap32[r6];
                        r7 = (r7 + 1) | 0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r6] = r7;
                        r5 = heapClassInst.heap32[r5 + -1];
                        heapClassInst.heap32[g0] = r5;
                        free(i7);
                      }
                      heapClassInst.heap32[r4 + numDefine3] = 0;
                    }
                    heapClassInst.heap8[sp + numDefineNeg8] = r2;
                    heapClassInst.heap32[r4 + numDefine3] = 0;
                    heapClassInst.heap32[r4 + numDefine2] = 0;
                  }
                  repeat20: while (true) {
                    r2 = r3 << numDefine2;
                    r5 = heapClassInst.heap32[r4 + numDefine3];
                    r2 = (r5 + r2) | 0;
                    r3 = (r3 + 1) | 0;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2] = 0;
                    if (!(r3 !== 0)) {
                      break repeat20;
                    }
                  }
                }
                heapClassInst.heap32[r4 + 1] = 0;
                r1 = heapClassInst.heap32[r1 + numDefine2];
                r2 = r1 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2 + numDefine4];
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                functionTable[r2 >> numDefine2](i7);
                r0 = heapClassInst.heap32[r4 + 1];
                r1 = 0;
                repeat23: while (true) {
                  if (r0 > r1) {
                    r2 = heapClassInst.heap32[r4 + numDefine3];
                    r3 = r1 << numDefine2;
                    r3 = (r2 + r3) | 0;
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3];
                    r3 = r3 >> numDefine2;
                    r3 = heapClassInst.heap32[r3 + numDefine279];
                    if (r3 > 0) {
                      break repeat23;
                    } else {
                      r1 = (r1 + 1) | 0;
                    }
                  } else {
                    break repeat7;
                  }
                }
                if (!(r2 === 0)) {
                  r0 = heapClassInst.heapU8[sp + numDefineNeg8];
                  if (!(r0 === 0)) {
                    r0 = gNumAlignedFree;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    r1 = (r1 + 1) | 0;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r0] = r1;
                    r0 = heapClassInst.heap32[r2 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                  }
                }
                r0 = 0;
                commonVariable.rg0 = r0;
                return;
              }
            }
          } while (false);
          r0 = heapClassInst.heap32[r4 + numDefine3];
          if (!(r0 === 0)) {
            r2 = heapClassInst.heapU8[sp + numDefineNeg8];
            if (!(r2 === 0)) {
              r2 = gNumAlignedFree;
              r2 = r2 >> numDefine2;
              r1 = heapClassInst.heap32[r2];
              r1 = (r1 + 1) | 0;
              r0 = r0 >> numDefine2;
              heapClassInst.heap32[r2] = r1;
              r0 = heapClassInst.heap32[r0 + -1];
              heapClassInst.heap32[g0] = r0;
              free(i7);
            }
          }
          r0 = 1;
          commonVariable.rg0 = r0;
          return;
        } else {
          r0 = 1;
          label = numDefine28;
        }
      }
    }
  } else {
    label = 1;
  }
  if (label === 1) {
    r0 = 0;
  }
  r0 = r0 & numDefine255;
  commonVariable.rg0 = r0;
  return;
}

function zn34btClosestNotMeConvexResultCallback15addSingleResultERN16btCollisionWorld17LocalConvexResultEb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp];
  r3 = heapClassInst.heap32[r1];
  r4 = r2 >> numDefine2;
  r5 = heapClassInst.heap32[r4 + numDefine20];
  if (!(r3 === r5)) {
    r3 = heapClassInst.heapU8[r3 + numDefine204];
    r3 = r3 & numDefine4;
    if (!(r3 !== 0)) {
      f0 = heapClassInst.heapFloat[r4 + numDefine7];
      f1 = heapClassInst.heapFloat[r4 + numDefine3];
      f2 = heapClassInst.heapFloat[r4 + numDefine8];
      f3 = heapClassInst.heapFloat[r4 + numDefine4];
      f4 = heapClassInst.heapFloat[r1 + numDefine2];
      f0 = f0 - f1;
      f1 = heapClassInst.heapFloat[r1 + numDefine3];
      f2 = f2 - f3;
      f3 = heapClassInst.heapFloat[r4 + numDefine9];
      f5 = heapClassInst.heapFloat[r4 + numDefine5];
      f0 = f4 * f0;
      f1 = f1 * f2;
      f2 = heapClassInst.heapFloat[r1 + numDefine4];
      f3 = f3 - f5;
      f4 = heapClassInst.heapFloat[r4 + numDefine21];
      f0 = f0 + f1;
      f1 = f2 * f3;
      f0 = f0 + f1;
      f1 = -f4;
      if (!(f0 >= f1)) {
        r1 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        zn16btCollisionWorld27ClosestConvexResultCallback15addSingleResultERNS17LocalConvexResultEb(i7);

        return;
      }
    }
  }
  f0 = 1;
  commonVariable.fg0 = f0;
  return;
}

function zn23btDiscreteDynamicsWorld19getConstraintSolverEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine44];
  commonVariable.rg0 = r0;
  return;
}

function znk23btDiscreteDynamicsWorld17getNumConstraintsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0 + numDefine47];
  commonVariable.rg0 = r0;
  return;
}

function zn23btDiscreteDynamicsWorld13getConstraintEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r0 = heapClassInst.heap32[r0 + numDefine49];
  r1 = r1 << numDefine2;
  r0 = (r0 + r1) | 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  commonVariable.rg0 = r0;
  return;
}

function zn23btDiscreteDynamicsWorld11clearForcesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r1 < 1)) {
    r1 = 0;
    repeat3: while (true) {
      r2 = heapClassInst.heap32[r0 + numDefine54];
      r3 = r1 << numDefine2;
      r2 = (r2 + r3) | 0;
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r2 = r2 >> numDefine2;
      r1 = (r1 + 1) | 0;
      heapClassInst.heap32[r2 + numDefine101] = 0;
      heapClassInst.heap32[r2 + numDefine102] = 0;
      heapClassInst.heap32[r2 + numDefine103] = 0;
      heapClassInst.heap32[r2 + numDefine104] = 0;
      heapClassInst.heap32[r2 + numDefine105] = 0;
      heapClassInst.heap32[r2 + numDefine106] = 0;
      heapClassInst.heap32[r2 + numDefine107] = 0;
      heapClassInst.heap32[r2 + numDefine108] = 0;
      r2 = heapClassInst.heap32[r0 + numDefine52];
      if (r2 > r1) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function znk23btDiscreteDynamicsWorld13getConstraintEi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r0 = heapClassInst.heap32[r0 + numDefine49];
  r1 = r1 << numDefine2;
  r0 = (r0 + r1) | 0;
  r0 = r0 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  commonVariable.rg0 = r0;
  return;
}

function zn23btDiscreteDynamicsWorld12removeActionEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r0 + numDefine63];
  r3 = 0;
  repeat1: while (true) {
    if (r2 > r3) {
      r4 = heapClassInst.heap32[r0 + numDefine65];
      r5 = r3 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      if (r4 !== r1) {
        r3 = (r3 + 1) | 0;
        continue repeat1;
      } else {
        label = numDefine5;
        break repeat1;
      }
    } else {
      label = numDefine4;
      break repeat1;
    }
  }
  if (label === numDefine4) {
    r3 = r2;
  }
  if (!(r2 <= r3)) {
    r1 = (r2 + -1) | 0;
    r2 = r3 << numDefine2;
    r3 = heapClassInst.heap32[r0 + numDefine65];
    r1 = r1 << numDefine2;
    r2 = (r3 + r2) | 0;
    r3 = (r3 + r1) | 0;
    r2 = r2 >> numDefine2;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r2];
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[r2] = r3;
    r2 = heapClassInst.heap32[r0 + numDefine65];
    r1 = (r2 + r1) | 0;
    r1 = r1 >> numDefine2;
    heapClassInst.heap32[r1] = r4;
    r1 = heapClassInst.heap32[r0 + numDefine63];
    r1 = (r1 + -1) | 0;
    heapClassInst.heap32[r0 + numDefine63] = r1;
  }
  return;
}

function zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine21];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine88];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine21] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine88] = r1;
  heapClassInst.heap32[r2 + numDefine21] = 0;
  heapClassInst.heap32[r2 + numDefine19] = 0;
  heapClassInst.heap32[r2 + numDefine20] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine16];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine68];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine16] = 0;
  }
  heapClassInst.heap8[r0 + numDefine68] = r1;
  heapClassInst.heap32[r2 + numDefine16] = 0;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine15] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine48];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine11] = 0;
  }
  heapClassInst.heap8[r0 + numDefine48] = r1;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = 0;
  return;
}

function zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine21];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine88];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine21] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine88] = r1;
  heapClassInst.heap32[r2 + numDefine21] = 0;
  heapClassInst.heap32[r2 + numDefine19] = 0;
  heapClassInst.heap32[r2 + numDefine20] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine16];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine68];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine16] = 0;
  }
  heapClassInst.heap8[r0 + numDefine68] = r1;
  heapClassInst.heap32[r2 + numDefine16] = 0;
  heapClassInst.heap32[r2 + numDefine14] = 0;
  heapClassInst.heap32[r2 + numDefine15] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine11];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine48];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine11] = 0;
  }
  heapClassInst.heap8[r0 + numDefine48] = r1;
  heapClassInst.heap32[r2 + numDefine11] = 0;
  heapClassInst.heap32[r2 + numDefine9] = 0;
  heapClassInst.heap32[r2 + numDefine10] = 0;
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn35btDiscrete(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + numDefine5];
  r3 = heapClassInst.heap32[fp + 1];
  r4 = heapClassInst.heap32[fp + numDefine2];
  r5 = heapClassInst.heap32[fp + numDefine3];
  r6 = heapClassInst.heap32[fp + numDefine4];
  r7 = heapClassInst.heap32[r1 + numDefine4];
  repeat1: do {
    if (r2 < 0) {
      r0 = 0;
      r0 = (r0 - r6) | 0;
      if (r7 === r0) {
        break repeat1;
      } else {
        r0 = heapClassInst.heap32[r1 + numDefine2];
        r2 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine3];
        r8 = heapClassInst.heap32[r1 + numDefine7];
        r9 = heapClassInst.heap32[r1 + numDefine6];
        r10 = heapClassInst.heap32[r1 + numDefine5];
        r11 = heapClassInst.heap32[r1 + 1];
        r1 = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = r5;
        heapClassInst.heap32[g0 + numDefine4] = r6;
        heapClassInst.heap32[g0 + numDefine5] = r1;
        heapClassInst.heap32[g0 + numDefine6] = r7;
        heapClassInst.heap32[g0 + numDefine7] = r11;
        heapClassInst.heap32[g0 + numDefine8] = r10;
        heapClassInst.heap32[g0 + numDefine9] = r9;
        heapClassInst.heap32[g0 + numDefine10] = r8;
        functionTable[r2 >> numDefine2](i7);
        return;
      }
    } else {
      r8 = 1;
      r9 = numDefine4;
      r10 = 0;
      repeat5: while (true) {
        if (r7 > r10) {
          r11 = heapClassInst.heap32[r1 + numDefine3];
          r12 = r10 << numDefine2;
          r12 = (r11 + r12) | 0;
          r12 = r12 >> numDefine2;
          r12 = heapClassInst.heap32[r12];
          r12 = r12 >> numDefine2;
          r13 = heapClassInst.heap32[r12 + numDefine5];
          r13 = r13 >> numDefine2;
          r13 = heapClassInst.heap32[r13 + numDefine52];
          if (r13 < 0) {
            r13 = heapClassInst.heap32[r12 + numDefine6];
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13 + numDefine52];
          }
          r10 = (r10 + 1) | 0;
          r9 = (r9 + numDefineNeg4) | 0;
          r8 = (r8 + -1) | 0;
          if (r13 === r2) {
            label = numDefine9;
            break repeat5;
          } else {
            label = numDefine7;
          }
        } else {
          label = numDefine8;
          break repeat5;
        }
      }
      repeat11: do {
        switch (label) {
          case numDefine9:
            r10 = r7 > r10 ? r7 : r10;
            r7 = (r11 - r9) | 0;
            r9 = (r10 + r8) | 0;
            r8 = 0;
            r10 = r7;
            while (true) {
              r11 = r10 >> numDefine2;
              r11 = heapClassInst.heap32[r11];
              r11 = r11 >> numDefine2;
              r12 = heapClassInst.heap32[r11 + numDefine5];
              r12 = r12 >> numDefine2;
              r12 = heapClassInst.heap32[r12 + numDefine52];
              if (r12 < 0) {
                r12 = heapClassInst.heap32[r11 + numDefine6];
                r12 = r12 >> numDefine2;
                r12 = heapClassInst.heap32[r12 + numDefine52];
              }

              r11 = r12 === r2 ? 1 : 0;
              r11 = r11 & 1;
              r9 = (r9 + -1) | 0;
              r8 = (r11 + r8) | 0;
              r10 = (r10 + numDefine4) | 0;
              if (!(r9 !== 0)) {
                break repeat11;
              }
            }
            break;
          case numDefine8:
            r7 = 0;
            r8 = r7;
            break;
          default:
            break;
        }
      } while (false);
      r2 = heapClassInst.heap32[r1 + 1];
      r9 = r2 >> numDefine2;
      r9 = heapClassInst.heap32[r9 + numDefine17];
      if (r9 < numDefine2) {
        r0 = 0;
        r0 = (r0 - r6) | 0;
        if (r8 === r0) {
          break repeat1;
        } else {
          r0 = heapClassInst.heap32[r1 + numDefine2];
          r9 = r0 >> numDefine2;
          r9 = heapClassInst.heap32[r9];
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefine3];
          r10 = heapClassInst.heap32[r1 + numDefine7];
          r11 = heapClassInst.heap32[r1 + numDefine6];
          r1 = heapClassInst.heap32[r1 + numDefine5];
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r3;
          heapClassInst.heap32[g0 + numDefine2] = r4;
          heapClassInst.heap32[g0 + numDefine3] = r5;
          heapClassInst.heap32[g0 + numDefine4] = r6;
          heapClassInst.heap32[g0 + numDefine5] = r7;
          heapClassInst.heap32[g0 + numDefine6] = r8;
          heapClassInst.heap32[g0 + numDefine7] = r2;
          heapClassInst.heap32[g0 + numDefine8] = r1;
          heapClassInst.heap32[g0 + numDefine9] = r11;
          heapClassInst.heap32[g0 + numDefine10] = r10;
          functionTable[r9 >> numDefine2](i7);
          return;
        }
      } else {
        repeat24: do {
          if (r4 > 0) {
            r2 = heapClassInst.heap32[r1 + numDefine9];
            while (true) {
              r9 = heapClassInst.heap32[r1 + numDefine10];
              if (r9 === r2) {
                r10 = 1;
                r11 = r2 << 1;
                r11 = r2 === 0 ? r10 : r11;
                if (!(r9 >= r11)) {
                  if (r11 !== 0) {
                    r9 = gNumAlignedAllocs;
                    r9 = r9 >> numDefine2;
                    r12 = heapClassInst.heap32[r9];
                    r13 = r11 << numDefine2;
                    r12 = (r12 + 1) | 0;
                    r13 = r13 | numDefine3;
                    heapClassInst.heap32[r9] = r12;
                    r9 = (r13 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r9;
                    mallocNew(i7);
                    r9 = commonVariable.rg0;
                    if (r9 !== 0) {
                      r12 = 0;
                      r13 = (r9 + numDefine4) | 0;
                      r12 = (r12 - r13) | 0;
                      r12 = r12 & numDefine15;
                      r12 = (r9 + r12) | 0;
                      r13 = (r12 + numDefine4) | 0;
                      r12 = r12 >> numDefine2;
                      heapClassInst.heap32[r12] = r9;
                      r9 = r13;
                    }
                  } else {
                    r9 = 0;
                  }
                  if (r2 < 1) {
                    r13 = heapClassInst.heap32[r1 + numDefine11];
                  } else {
                    r12 = 0;
                    repeat39: while (true) {
                      r13 = heapClassInst.heap32[r1 + numDefine11];
                      r14 = r12 << numDefine2;
                      r15 = (r13 + r14) | 0;
                      r15 = r15 >> numDefine2;
                      r14 = (r9 + r14) | 0;
                      r15 = heapClassInst.heap32[r15];
                      r12 = (r12 + 1) | 0;
                      r14 = r14 >> numDefine2;
                      heapClassInst.heap32[r14] = r15;
                      if (!(r2 !== r12)) {
                        break repeat39;
                      }
                    }
                  }
                  if (r13 !== 0) {
                    r12 = heapClassInst.heapU8[r0 + numDefine48];
                    if (r12 !== 0) {
                      r2 = gNumAlignedFree;
                      r2 = r2 >> numDefine2;
                      r12 = heapClassInst.heap32[r2];
                      r12 = (r12 + 1) | 0;
                      r13 = r13 >> numDefine2;
                      heapClassInst.heap32[r2] = r12;
                      r2 = heapClassInst.heap32[r13 + -1];
                      heapClassInst.heap32[g0] = r2;
                      free(i7);
                      r2 = heapClassInst.heap32[r1 + numDefine9];
                    }
                    heapClassInst.heap32[r1 + numDefine11] = 0;
                  }
                  heapClassInst.heap8[r0 + numDefine48] = r10;
                  heapClassInst.heap32[r1 + numDefine11] = r9;
                  heapClassInst.heap32[r1 + numDefine10] = r11;
                }
              }
              r9 = r3 >> numDefine2;
              r2 = r2 << numDefine2;
              r10 = heapClassInst.heap32[r1 + numDefine11];
              r2 = (r10 + r2) | 0;
              r9 = heapClassInst.heap32[r9];
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2] = r9;
              r2 = heapClassInst.heap32[r1 + numDefine9];
              r2 = (r2 + 1) | 0;
              r4 = (r4 + -1) | 0;
              r3 = (r3 + numDefine4) | 0;
              heapClassInst.heap32[r1 + numDefine9] = r2;
              if (!(r4 !== 0)) {
                break repeat24;
              }
            }
          }
        } while (false);
        repeat50: do {
          if (!(r6 < 1)) {
            r2 = heapClassInst.heap32[r1 + numDefine14];
            while (true) {
              r3 = heapClassInst.heap32[r1 + numDefine15];
              if (r3 === r2) {
                r4 = 1;
                r9 = r2 << 1;
                r9 = r2 === 0 ? r4 : r9;
                if (!(r3 >= r9)) {
                  if (r9 !== 0) {
                    r3 = gNumAlignedAllocs;
                    r3 = r3 >> numDefine2;
                    r10 = heapClassInst.heap32[r3];
                    r11 = r9 << numDefine2;
                    r10 = (r10 + 1) | 0;
                    r11 = r11 | numDefine3;
                    heapClassInst.heap32[r3] = r10;
                    r3 = (r11 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r3;
                    mallocNew(i7);
                    r3 = commonVariable.rg0;
                    if (r3 !== 0) {
                      r10 = 0;
                      r11 = (r3 + numDefine4) | 0;
                      r10 = (r10 - r11) | 0;
                      r10 = r10 & numDefine15;
                      r10 = (r3 + r10) | 0;
                      r11 = (r10 + numDefine4) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r3;
                      r3 = r11;
                    }
                  } else {
                    r3 = 0;
                  }
                  if (r2 < 1) {
                    r11 = heapClassInst.heap32[r1 + numDefine16];
                  } else {
                    r10 = 0;
                    repeat65: while (true) {
                      r11 = heapClassInst.heap32[r1 + numDefine16];
                      r12 = r10 << numDefine2;
                      r13 = (r11 + r12) | 0;
                      r13 = r13 >> numDefine2;
                      r12 = (r3 + r12) | 0;
                      r13 = heapClassInst.heap32[r13];
                      r10 = (r10 + 1) | 0;
                      r12 = r12 >> numDefine2;
                      heapClassInst.heap32[r12] = r13;
                      if (!(r2 !== r10)) {
                        break repeat65;
                      }
                    }
                  }
                  if (r11 !== 0) {
                    r10 = heapClassInst.heapU8[r0 + numDefine68];
                    if (r10 !== 0) {
                      r2 = gNumAlignedFree;
                      r2 = r2 >> numDefine2;
                      r10 = heapClassInst.heap32[r2];
                      r10 = (r10 + 1) | 0;
                      r11 = r11 >> numDefine2;
                      heapClassInst.heap32[r2] = r10;
                      r2 = heapClassInst.heap32[r11 + -1];
                      heapClassInst.heap32[g0] = r2;
                      free(i7);
                      r2 = heapClassInst.heap32[r1 + numDefine14];
                    }
                    heapClassInst.heap32[r1 + numDefine16] = 0;
                  }
                  heapClassInst.heap8[r0 + numDefine68] = r4;
                  heapClassInst.heap32[r1 + numDefine16] = r3;
                  heapClassInst.heap32[r1 + numDefine15] = r9;
                }
              }
              r3 = r5 >> numDefine2;
              r2 = r2 << numDefine2;
              r4 = heapClassInst.heap32[r1 + numDefine16];
              r2 = (r4 + r2) | 0;
              r3 = heapClassInst.heap32[r3];
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2] = r3;
              r2 = heapClassInst.heap32[r1 + numDefine14];
              r2 = (r2 + 1) | 0;
              r6 = (r6 + -1) | 0;
              r5 = (r5 + numDefine4) | 0;
              heapClassInst.heap32[r1 + numDefine14] = r2;
              if (!(r6 !== 0)) {
                break repeat50;
              }
            }
          }
        } while (false);
        repeat76: do {
          if (r8 > 0) {
            r2 = heapClassInst.heap32[r1 + numDefine19];
            while (true) {
              r3 = heapClassInst.heap32[r1 + numDefine20];
              if (r3 === r2) {
                r4 = 1;
                r5 = r2 << 1;
                r5 = r2 === 0 ? r4 : r5;
                if (!(r3 >= r5)) {
                  if (r5 !== 0) {
                    r3 = gNumAlignedAllocs;
                    r3 = r3 >> numDefine2;
                    r6 = heapClassInst.heap32[r3];
                    r9 = r5 << numDefine2;
                    r6 = (r6 + 1) | 0;
                    r9 = r9 | numDefine3;
                    heapClassInst.heap32[r3] = r6;
                    r3 = (r9 + numDefine16) | 0;
                    heapClassInst.heap32[g0] = r3;
                    mallocNew(i7);
                    r3 = commonVariable.rg0;
                    if (r3 !== 0) {
                      r6 = 0;
                      r9 = (r3 + numDefine4) | 0;
                      r6 = (r6 - r9) | 0;
                      r6 = r6 & numDefine15;
                      r6 = (r3 + r6) | 0;
                      r9 = (r6 + numDefine4) | 0;
                      r6 = r6 >> numDefine2;
                      heapClassInst.heap32[r6] = r3;
                      r3 = r9;
                    }
                  } else {
                    r3 = 0;
                  }
                  if (r2 < 1) {
                    r9 = heapClassInst.heap32[r1 + numDefine21];
                  } else {
                    r6 = 0;
                    repeat91: while (true) {
                      r9 = heapClassInst.heap32[r1 + numDefine21];
                      r10 = r6 << numDefine2;
                      r11 = (r9 + r10) | 0;
                      r11 = r11 >> numDefine2;
                      r10 = (r3 + r10) | 0;
                      r11 = heapClassInst.heap32[r11];
                      r6 = (r6 + 1) | 0;
                      r10 = r10 >> numDefine2;
                      heapClassInst.heap32[r10] = r11;
                      if (!(r2 !== r6)) {
                        break repeat91;
                      }
                    }
                  }
                  if (r9 !== 0) {
                    r6 = heapClassInst.heapU8[r0 + numDefine88];
                    if (r6 !== 0) {
                      r2 = gNumAlignedFree;
                      r2 = r2 >> numDefine2;
                      r6 = heapClassInst.heap32[r2];
                      r6 = (r6 + 1) | 0;
                      r9 = r9 >> numDefine2;
                      heapClassInst.heap32[r2] = r6;
                      r2 = heapClassInst.heap32[r9 + -1];
                      heapClassInst.heap32[g0] = r2;
                      free(i7);
                      r2 = heapClassInst.heap32[r1 + numDefine19];
                    }
                    heapClassInst.heap32[r1 + numDefine21] = 0;
                  }
                  heapClassInst.heap8[r0 + numDefine88] = r4;
                  heapClassInst.heap32[r1 + numDefine21] = r3;
                  heapClassInst.heap32[r1 + numDefine20] = r5;
                }
              }
              r3 = r7 >> numDefine2;
              r2 = r2 << numDefine2;
              r4 = heapClassInst.heap32[r1 + numDefine21];
              r2 = (r4 + r2) | 0;
              r3 = heapClassInst.heap32[r3];
              r2 = r2 >> numDefine2;
              heapClassInst.heap32[r2] = r3;
              r2 = heapClassInst.heap32[r1 + numDefine19];
              r2 = (r2 + 1) | 0;
              r8 = (r8 + -1) | 0;
              r7 = (r7 + numDefine4) | 0;
              heapClassInst.heap32[r1 + numDefine19] = r2;
              if (!(r8 !== 0)) {
                break repeat76;
              }
            }
          } else {
            r2 = heapClassInst.heap32[r1 + numDefine19];
          }
        } while (false);
        r3 = heapClassInst.heap32[r1 + 1];
        r3 = r3 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine14];
        r1 = (r1 + r2) | 0;
        r2 = heapClassInst.heap32[r3 + numDefine17];
        if (!(r1 <= r2)) {
          heapClassInst.heap32[g0] = r0;
          zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(i7);
        }
      }
    }
  } while (false);
  return;
}

function zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + numDefine2];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = (r0 + r1) | 0;
  r3 = r2 >>> numDefine31;
  r4 = heapClassInst.heap32[fp];
  r2 = (r2 + r3) | 0;
  r3 = r4 >> numDefine2;
  r2 = r2 & numDefine83646;
  r5 = heapClassInst.heap32[r3 + numDefine3];
  r2 = r2 << 1;
  r2 = (r5 + r2) | 0;
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r5 = r1;
  r6 = r0;
  repeat1: while (true) {
    r7 = r2 >> numDefine2;
    r8 = heapClassInst.heap32[r7 + numDefine5];
    r8 = r8 >> numDefine2;
    r9 = heapClassInst.heap32[r3 + numDefine3];
    r8 = heapClassInst.heap32[r8 + numDefine52];
    repeat3: while (true) {
      r10 = r5 << numDefine2;
      r10 = (r9 + r10) | 0;
      r10 = r10 >> numDefine2;
      r11 = heapClassInst.heap32[r10];
      if (r8 < 0) {
        r12 = heapClassInst.heap32[r7 + numDefine6];
        r12 = r12 >> numDefine2;
        r12 = heapClassInst.heap32[r12 + numDefine52];
      } else {
        r12 = r8;
      }
      r13 = r11 >> numDefine2;
      r14 = heapClassInst.heap32[r13 + numDefine5];
      r14 = r14 >> numDefine2;
      r14 = heapClassInst.heap32[r14 + numDefine52];
      if (r14 < 0) {
        r14 = heapClassInst.heap32[r13 + numDefine6];
        r14 = r14 >> numDefine2;
        r14 = heapClassInst.heap32[r14 + numDefine52];
      }
      if (r14 < r12) {
        r5 = (r5 + 1) | 0;
        continue repeat3;
      } else {
        break repeat3;
      }
    }
    repeat13: while (true) {
      r12 = r6 << numDefine2;
      r13 = (r9 + r12) | 0;
      r13 = r13 >> numDefine2;
      r13 = heapClassInst.heap32[r13];
      r14 = r13 >> numDefine2;
      r15 = heapClassInst.heap32[r14 + numDefine5];
      r15 = r15 >> numDefine2;
      r15 = heapClassInst.heap32[r15 + numDefine52];
      if (r15 < 0) {
        r15 = heapClassInst.heap32[r14 + numDefine6];
        r15 = r15 >> numDefine2;
        r15 = heapClassInst.heap32[r15 + numDefine52];
      }
      if (r8 < 0) {
        r14 = heapClassInst.heap32[r7 + numDefine6];
        r14 = r14 >> numDefine2;
        r14 = heapClassInst.heap32[r14 + numDefine52];
      } else {
        r14 = r8;
      }
      if (r14 < r15) {
        r6 = (r6 + -1) | 0;
        continue repeat13;
      } else {
        break repeat13;
      }
    }
    if (r5 <= r6) {
      heapClassInst.heap32[r10] = r13;
      r7 = heapClassInst.heap32[r3 + numDefine3];
      r7 = (r7 + r12) | 0;
      r5 = (r5 + 1) | 0;
      r6 = (r6 + -1) | 0;
      r7 = r7 >> numDefine2;
      heapClassInst.heap32[r7] = r11;
    }
    if (r5 <= r6) {
      continue repeat1;
    } else {
      break repeat1;
    }
  }
  if (!(r6 <= r1)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = r6;
    zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
  }
  if (!(r5 >= r0)) {
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r5;
    heapClassInst.heap32[g0 + numDefine2] = r0;
    zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
  }
  return;
}

function zn23btDiscreteDynamicsWorld9serializeEP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine8];
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r4 = r3 >> numDefine2;
  functionTable[r2 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r4 + numDefine2];
  if (!(r2 < 1)) {
    r2 = 0;
    repeat3: while (true) {
      r5 = heapClassInst.heap32[r4 + numDefine4];
      r6 = r2 << numDefine2;
      r5 = (r5 + r6) | 0;
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      r6 = heapClassInst.heapU8[r5 + numDefine232];
      r6 = r6 & numDefine2;
      if (!(r6 === 0)) {
        r6 = r5 >> numDefine2;
        r7 = heapClassInst.heap32[r6];
        r7 = r7 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine4];
        heapClassInst.heap32[g0] = r5;
        functionTable[r7 >> numDefine2](i7);
        r8 = heapClassInst.heap32[r1];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable[r8 >> numDefine2](i7);
        r7 = commonVariable.rg0;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r8 = r7 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine5];
        r8 = heapClassInst.heap32[r8 + numDefine2];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r8;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        functionTable[r6 >> numDefine2](i7);
        r8 = heapClassInst.heap32[r1];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine5];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = numDefine45650;
        heapClassInst.heap32[g0 + numDefine4] = r5;
        functionTable[r8 >> numDefine2](i7);
      }
      r2 = (r2 + 1) | 0;
      r5 = heapClassInst.heap32[r4 + numDefine2];
      if (r5 > r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r2 = heapClassInst.heap32[r4 + numDefine47];
  repeat9: do {
    if (!(r2 < 1)) {
      r2 = 0;
      repeat11: while (true) {
        r5 = r2 << numDefine2;
        r6 = heapClassInst.heap32[r4 + numDefine49];
        r5 = (r6 + r5) | 0;
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r6 = r5 >> numDefine2;
        r7 = heapClassInst.heap32[r6];
        r7 = r7 >> numDefine2;
        r7 = heapClassInst.heap32[r7 + numDefine9];
        heapClassInst.heap32[g0] = r5;
        functionTable[r7 >> numDefine2](i7);
        r8 = heapClassInst.heap32[r1];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        functionTable[r8 >> numDefine2](i7);
        r7 = commonVariable.rg0;
        r6 = heapClassInst.heap32[r6];
        r6 = r6 >> numDefine2;
        r8 = r7 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine10];
        r8 = heapClassInst.heap32[r8 + numDefine2];
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r8;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        functionTable[r6 >> numDefine2](i7);
        r8 = heapClassInst.heap32[r1];
        r8 = r8 >> numDefine2;
        r8 = heapClassInst.heap32[r8 + numDefine5];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
        heapClassInst.heap32[g0 + numDefine3] = numDefine41027;
        heapClassInst.heap32[g0 + numDefine4] = r5;
        r2 = (r2 + 1) | 0;
        functionTable[r8 >> numDefine2](i7);
        r5 = heapClassInst.heap32[r4 + numDefine47];
        if (r5 > r2) {
          continue repeat11;
        } else {
          break repeat9;
        }
      }
    }
  } while (false);
  heapClassInst.heap32[g0] = r3;
  heapClassInst.heap32[g0 + 1] = r0;
  zn16btCollisionWorld25serializeCollisionObjectsEP12btSerializer(i7);
  r1 = heapClassInst.heap32[r1];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine9];
  heapClassInst.heap32[g0] = r0;
  functionTable[r1 >> numDefine2](i7);
  return;
}

function zn23btDiscreteDynamicsWorld19setConstraintSolverEP18btConstraintSolver(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine245];
  if (!(r1 === 0)) {
    r1 = r0 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine44];
    if (!(r1 === 0)) {
      r2 = gNumAlignedFree;
      r2 = r2 >> numDefine2;
      r3 = heapClassInst.heap32[r2];
      r3 = (r3 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r2] = r3;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heap32[fp + 1];
  r2 = 0;
  r3 = r0 >> numDefine2;
  heapClassInst.heap8[r0 + numDefine245] = r2;
  heapClassInst.heap32[r3 + numDefine44] = r1;
  return;
}

function zn23btDiscreteDynamicsWorld25predictUnconstraintMotionEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr87;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r1 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r1 < 1)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    r1 = 0;
    repeat3: while (true) {
      r2 = heapClassInst.heap32[r0 + numDefine54];
      r3 = r1 << numDefine2;
      r2 = (r2 + r3) | 0;
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r3 = heapClassInst.heapU8[r2 + numDefine204];
      r3 = r3 & numDefine3;
      if (!(r3 !== 0)) {
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heapFloat[g0 + 1] = f0;
        zn11btRigidBody19integrateVelocitiesEf(i7);
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heapFloat[g0 + 1] = f0;
        zn11btRigidBody12applyDampingEf(i7);
        r3 = r2 >> numDefine2;
        f1 = heapClassInst.heapFloat[r3 + numDefine76];
        f2 = heapClassInst.heapFloat[r3 + numDefine77];
        f3 = heapClassInst.heapFloat[r3 + numDefine78];
        r3 = (r2 + numDefine4) | 0;
        r4 = (r2 + numDefine320) | 0;
        r2 = (r2 + numDefine68) | 0;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heapFloat[g0 + 1] = f1;
        heapClassInst.heapFloat[g0 + numDefine2] = f2;
        heapClassInst.heapFloat[g0 + numDefine3] = f3;
        heapClassInst.heap32[g0 + numDefine4] = r4;
        heapClassInst.heapFloat[g0 + numDefine5] = f0;
        heapClassInst.heap32[g0 + numDefine6] = r2;
        zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
      }
      r1 = (r1 + 1) | 0;
      r2 = heapClassInst.heap32[r0 + numDefine52];
      if (r2 > r1) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat9: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat9;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld26calculateSimulationIslandsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr188;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  zn15CProfileManager13StartProfileEPKc(i7);
  r0 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + numDefine45];
  r3 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine2];
  r4 = heapClassInst.heap32[r0 + numDefine6];
  heapClassInst.heap32[g0] = r2;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r4;
  functionTable[r3 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r0 + numDefine47];
  if (!(r2 < 1)) {
    r3 = 0;
    repeat3: while (true) {
      r4 = heapClassInst.heap32[r0 + numDefine49];
      r5 = r3 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4 + numDefine5];
      repeat5: do {
        if (!(r5 === 0)) {
          r6 = heapClassInst.heapU8[r5 + numDefine204];
          r6 = r6 & numDefine3;
          if (!(r6 !== 0)) {
            r4 = heapClassInst.heap32[r4 + numDefine6];
            if (!(r4 === 0)) {
              r6 = heapClassInst.heapU8[r4 + numDefine204];
              r6 = r6 & numDefine3;
              if (!(r6 !== 0)) {
                r5 = r5 >> numDefine2;
                r6 = heapClassInst.heap32[r5 + numDefine54];
                if (r6 === numDefine2) {
                  label = numDefine8;
                } else {
                  if (r6 !== numDefine5) {
                    label = numDefine10;
                  } else {
                    label = numDefine8;
                  }
                }
                if (label === numDefine8) {
                  r6 = r4 >> numDefine2;
                  r6 = heapClassInst.heap32[r6 + numDefine54];
                  if (r6 === numDefine2) {
                    break repeat5;
                  } else {
                    if (r6 === numDefine5) {
                      break repeat5;
                    }
                  }
                }
                r6 = heapClassInst.heap32[r0 + numDefine45];
                r5 = heapClassInst.heap32[r5 + numDefine52];
                r6 = r6 >> numDefine2;
                r7 = heapClassInst.heap32[r6 + numDefine4];
                r8 = r5 << numDefine3;
                r8 = (r7 + r8) | 0;
                r8 = r8 >> numDefine2;
                r4 = r4 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                r4 = heapClassInst.heap32[r4 + numDefine52];
                if (!(r8 === r5)) {
                  repeat17: while (true) {
                    r8 = r8 << numDefine3;
                    r5 = r5 << numDefine3;
                    r8 = (r7 + r8) | 0;
                    r5 = (r7 + r5) | 0;
                    r7 = r8 >> numDefine2;
                    r5 = r5 >> numDefine2;
                    r8 = heapClassInst.heap32[r7];
                    heapClassInst.heap32[r5] = r8;
                    r5 = heapClassInst.heap32[r7];
                    r7 = heapClassInst.heap32[r6 + numDefine4];
                    r8 = r5 << numDefine3;
                    r8 = (r7 + r8) | 0;
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8];
                    if (!(r8 !== r5)) {
                      break repeat17;
                    }
                  }
                }
                r8 = r4 << numDefine3;
                r8 = (r7 + r8) | 0;
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                repeat20: do {
                  if (!(r8 === r4)) {
                    while (true) {
                      r8 = r8 << numDefine3;
                      r4 = r4 << numDefine3;
                      r8 = (r7 + r8) | 0;
                      r4 = (r7 + r4) | 0;
                      r7 = r8 >> numDefine2;
                      r4 = r4 >> numDefine2;
                      r8 = heapClassInst.heap32[r7];
                      heapClassInst.heap32[r4] = r8;
                      r4 = heapClassInst.heap32[r7];
                      r7 = heapClassInst.heap32[r6 + numDefine4];
                      r8 = r4 << numDefine3;
                      r8 = (r7 + r8) | 0;
                      r8 = r8 >> numDefine2;
                      r8 = heapClassInst.heap32[r8];
                      if (!(r8 !== r4)) {
                        break repeat20;
                      }
                    }
                  }
                } while (false);
                if (!(r5 === r4)) {
                  r5 = r5 << numDefine3;
                  r7 = (r7 + r5) | 0;
                  r7 = r7 >> numDefine2;
                  heapClassInst.heap32[r7] = r4;
                  r6 = heapClassInst.heap32[r6 + numDefine4];
                  r4 = r4 << numDefine3;
                  r4 = (r6 + r4) | 0;
                  r5 = (r6 + r5) | 0;
                  r4 = r4 >> numDefine2;
                  r5 = r5 >> numDefine2;
                  r6 = heapClassInst.heap32[r4 + 1];
                  r5 = heapClassInst.heap32[r5 + 1];
                  r5 = (r5 + r6) | 0;
                  heapClassInst.heap32[r4 + 1] = r5;
                }
              }
            }
          }
        }
      } while (false);
      r3 = (r3 + 1) | 0;
      if (r2 !== r3) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r0 = heapClassInst.heap32[r0 + numDefine45];
  r2 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  r0 = zn15CProfileManager11CurrentNodeE;
  functionTable[r2 >> numDefine2](i7);
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat27: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat27;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine14];
  r3 = heapClassInst.heap32[r1 + numDefine19];
  r4 = (r3 + r2) | 0;
  if (!(r4 < 1)) {
    r4 = heapClassInst.heap32[r1 + numDefine2];
    r5 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine3];
    r6 = heapClassInst.heap32[r1 + numDefine7];
    r7 = heapClassInst.heap32[r1 + numDefine6];
    r8 = heapClassInst.heap32[r1 + numDefine5];
    r9 = heapClassInst.heap32[r1 + 1];
    r10 = heapClassInst.heap32[r1 + numDefine21];
    r11 = heapClassInst.heap32[r1 + numDefine16];
    r12 = heapClassInst.heap32[r1 + numDefine9];
    r13 = heapClassInst.heap32[r1 + numDefine11];
    heapClassInst.heap32[g0] = r4;
    heapClassInst.heap32[g0 + 1] = r13;
    heapClassInst.heap32[g0 + numDefine2] = r12;
    heapClassInst.heap32[g0 + numDefine3] = r11;
    heapClassInst.heap32[g0 + numDefine4] = r2;
    heapClassInst.heap32[g0 + numDefine5] = r10;
    heapClassInst.heap32[g0 + numDefine6] = r3;
    heapClassInst.heap32[g0 + numDefine7] = r9;
    heapClassInst.heap32[g0 + numDefine8] = r8;
    heapClassInst.heap32[g0 + numDefine9] = r7;
    heapClassInst.heap32[g0 + numDefine10] = r6;
    functionTable[r5 >> numDefine2](i7);
  }
  r2 = heapClassInst.heap32[r1 + numDefine9];
  if (!(r2 > -1)) {
    r3 = heapClassInst.heap32[r1 + numDefine10];
    if (!(r3 > -1)) {
      r3 = heapClassInst.heap32[r1 + numDefine11];
      if (!(r3 === 0)) {
        r4 = heapClassInst.heapU8[r0 + numDefine48];
        if (!(r4 === 0)) {
          r4 = gNumAlignedFree;
          r4 = r4 >> numDefine2;
          r5 = heapClassInst.heap32[r4];
          r5 = (r5 + 1) | 0;
          r3 = r3 >> numDefine2;
          heapClassInst.heap32[r4] = r5;
          r3 = heapClassInst.heap32[r3 + -1];
          heapClassInst.heap32[g0] = r3;
          free(i7);
        }
        heapClassInst.heap32[r1 + numDefine11] = 0;
      }
      r3 = 1;
      heapClassInst.heap8[r0 + numDefine48] = r3;
      heapClassInst.heap32[r1 + numDefine11] = 0;
      heapClassInst.heap32[r1 + numDefine10] = 0;
    }
    repeat14: while (true) {
      r3 = r2 << numDefine2;
      r4 = heapClassInst.heap32[r1 + numDefine11];
      r3 = (r4 + r3) | 0;
      r2 = (r2 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r3] = 0;
      if (r2 !== 0) {
        continue repeat14;
      } else {
        break repeat14;
      }
    }
  }
  heapClassInst.heap32[r1 + numDefine9] = 0;
  r2 = heapClassInst.heap32[r1 + numDefine14];
  repeat17: do {
    if (!(r2 > -1)) {
      r3 = heapClassInst.heap32[r1 + numDefine15];
      if (!(r3 > -1)) {
        r3 = heapClassInst.heap32[r1 + numDefine16];
        if (!(r3 === 0)) {
          r4 = heapClassInst.heapU8[r0 + numDefine68];
          if (!(r4 === 0)) {
            r4 = gNumAlignedFree;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r5 = (r5 + 1) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r4] = r5;
            r3 = heapClassInst.heap32[r3 + -1];
            heapClassInst.heap32[g0] = r3;
            free(i7);
          }
          heapClassInst.heap32[r1 + numDefine16] = 0;
        }
        r3 = 1;
        heapClassInst.heap8[r0 + numDefine68] = r3;
        heapClassInst.heap32[r1 + numDefine16] = 0;
        heapClassInst.heap32[r1 + numDefine15] = 0;
      }
      repeat27: while (true) {
        r3 = r2 << numDefine2;
        r4 = heapClassInst.heap32[r1 + numDefine16];
        r3 = (r4 + r3) | 0;
        r2 = (r2 + 1) | 0;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r3] = 0;
        if (r2 !== 0) {
          continue repeat27;
        } else {
          break repeat17;
        }
      }
    }
  } while (false);
  heapClassInst.heap32[r1 + numDefine14] = 0;
  r2 = heapClassInst.heap32[r1 + numDefine19];
  repeat30: do {
    if (!(r2 > -1)) {
      r3 = heapClassInst.heap32[r1 + numDefine20];
      if (!(r3 > -1)) {
        r3 = heapClassInst.heap32[r1 + numDefine21];
        if (!(r3 === 0)) {
          r4 = heapClassInst.heapU8[r0 + numDefine88];
          if (!(r4 === 0)) {
            r4 = gNumAlignedFree;
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r5 = (r5 + 1) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r4] = r5;
            r3 = heapClassInst.heap32[r3 + -1];
            heapClassInst.heap32[g0] = r3;
            free(i7);
          }
          heapClassInst.heap32[r1 + numDefine21] = 0;
        }
        r3 = 1;
        heapClassInst.heap8[r0 + numDefine88] = r3;
        heapClassInst.heap32[r1 + numDefine21] = 0;
        heapClassInst.heap32[r1 + numDefine20] = 0;
      }
      repeat40: while (true) {
        r0 = r2 << numDefine2;
        r3 = heapClassInst.heap32[r1 + numDefine21];
        r0 = (r3 + r0) | 0;
        r2 = (r2 + 1) | 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = 0;
        if (r2 !== 0) {
          continue repeat40;
        } else {
          break repeat30;
        }
      }
    }
  } while (false);
  heapClassInst.heap32[r1 + numDefine19] = 0;
  return;
}

function zn23btDiscreteDynamicsWorld9addActionEP17btActionInterface(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine64];
  r3 = heapClassInst.heap32[r1 + numDefine63];
  r4 = heapClassInst.heap32[fp + 1];
  if (r2 === r3) {
    r5 = 1;
    r6 = r3 << 1;
    r6 = r3 === 0 ? r5 : r6;
    if (!(r2 >= r6)) {
      if (r6 !== 0) {
        r2 = gNumAlignedAllocs;
        r2 = r2 >> numDefine2;
        r7 = heapClassInst.heap32[r2];
        r8 = r6 << numDefine2;
        r7 = (r7 + 1) | 0;
        r8 = r8 | numDefine3;
        heapClassInst.heap32[r2] = r7;
        r2 = (r8 + numDefine16) | 0;
        heapClassInst.heap32[g0] = r2;
        mallocNew(i7);
        r2 = commonVariable.rg0;
        if (r2 !== 0) {
          r7 = 0;
          r8 = (r2 + numDefine4) | 0;
          r7 = (r7 - r8) | 0;
          r7 = r7 & numDefine15;
          r7 = (r2 + r7) | 0;
          r8 = (r7 + numDefine4) | 0;
          r7 = r7 >> numDefine2;
          heapClassInst.heap32[r7] = r2;
          r2 = r8;
        }
      } else {
        r2 = 0;
      }
      r7 = (r0 + numDefine260) | 0;
      if (r3 < 1) {
        r8 = r7 >> numDefine2;
        r9 = heapClassInst.heap32[r8];
      } else {
        r8 = 0;
        repeat12: while (true) {
          r9 = r7 >> numDefine2;
          r9 = heapClassInst.heap32[r9];
          r10 = r8 << numDefine2;
          r11 = (r9 + r10) | 0;
          r11 = r11 >> numDefine2;
          r10 = (r2 + r10) | 0;
          r11 = heapClassInst.heap32[r11];
          r8 = (r8 + 1) | 0;
          r10 = r10 >> numDefine2;
          heapClassInst.heap32[r10] = r11;
          if (!(r3 !== r8)) {
            break repeat12;
          }
        }
        r7 = (r0 + numDefine260) | 0;
      }
      if (r9 !== 0) {
        r8 = heapClassInst.heapU8[r0 + numDefine264];
        if (r8 !== 0) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r8 = heapClassInst.heap32[r3];
          r8 = (r8 + 1) | 0;
          r9 = r9 >> numDefine2;
          heapClassInst.heap32[r3] = r8;
          r3 = heapClassInst.heap32[r9 + -1];
          heapClassInst.heap32[g0] = r3;
          free(i7);
          r3 = heapClassInst.heap32[r1 + numDefine63];
        }
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[r8] = 0;
      }
      r7 = r7 >> numDefine2;
      heapClassInst.heap8[r0 + numDefine264] = r5;
      heapClassInst.heap32[r7] = r2;
      heapClassInst.heap32[r1 + numDefine64] = r6;
    }
  }
  r0 = r3 << numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine65];
  r0 = (r2 + r0) | 0;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = r4;
  r0 = heapClassInst.heap32[r1 + numDefine63];
  r0 = (r0 + 1) | 0;
  heapClassInst.heap32[r1 + numDefine63] = r0;
  return;
}

function zn23btDiscreteDynamicsWorld19integrateTransformsEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg264;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr794;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r2 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r2 < 1)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    r2 = 0;
    r15 = -1;
    repeat3: while (true) {
      r3 = heapClassInst.heap32[r0 + numDefine54];
      r4 = r2 << numDefine2;
      r3 = (r3 + r4) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r4 + numDefine60] = numDefine53216;
      r5 = heapClassInst.heap32[r4 + numDefine54];
      if (!(r5 === numDefine2)) {
        if (!(r5 === numDefine5)) {
          r5 = heapClassInst.heapU8[r3 + numDefine204];
          r5 = r5 & numDefine3;
          if (!(r5 !== 0)) {
            f1 = heapClassInst.heapFloat[r4 + numDefine76];
            f2 = heapClassInst.heapFloat[r4 + numDefine77];
            f3 = heapClassInst.heapFloat[r4 + numDefine78];
            r5 = (r3 + numDefine320) | 0;
            r6 = (r3 + numDefine4) | 0;
            r7 = sp + numDefineNeg80;
            heapClassInst.heap32[g0] = r6;
            heapClassInst.heapFloat[g0 + 1] = f1;
            heapClassInst.heapFloat[g0 + numDefine2] = f2;
            heapClassInst.heapFloat[g0 + numDefine3] = f3;
            heapClassInst.heap32[g0 + numDefine4] = r5;
            heapClassInst.heapFloat[g0 + numDefine5] = f0;
            heapClassInst.heap32[g0 + numDefine6] = r7;
            zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
            f1 = heapClassInst.heapFloat[r4 + numDefine62];
            f1 = f1 * f1;
            f2 = 0;
            repeat9: do {
              if (!(f1 === f2)) {
                r8 = r7 >> numDefine2;
                f2 = heapClassInst.heapFloat[r8 + numDefine14];
                f3 = heapClassInst.heapFloat[r4 + numDefine15];
                f4 = heapClassInst.heapFloat[r8 + numDefine13];
                f5 = heapClassInst.heapFloat[r4 + numDefine14];
                f6 = heapClassInst.heapFloat[r8 + numDefine12];
                f7 = heapClassInst.heapFloat[r4 + numDefine13];
                f2 = f2 - f3;
                f3 = f4 - f5;
                f4 = f6 - f7;
                f4 = f4 * f4;
                f3 = f3 * f3;
                f3 = f4 + f3;
                f2 = f2 * f2;
                f2 = f3 + f2;
                if (!(f1 >= f2)) {
                  r9 = twoEStr895;
                  heapClassInst.heap32[g0] = r9;
                  zn15CProfileManager13StartProfileEPKc(i7);
                  r9 = heapClassInst.heap32[r4 + numDefine48];
                  r9 = r9 >> numDefine2;
                  r9 = heapClassInst.heap32[r9 + 1];
                  if (!(r9 > numDefine19)) {
                    r9 = gNumClampedCcdMotions;
                    r9 = r9 >> numDefine2;
                    r10 = heapClassInst.heap32[r9];
                    r10 = (r10 + 1) | 0;
                    heapClassInst.heap32[r9] = r10;
                    r9 = heapClassInst.heap32[r0 + numDefine20];
                    r10 = r9 >> numDefine2;
                    r10 = heapClassInst.heap32[r10];
                    r10 = r10 >> numDefine2;
                    r10 = heapClassInst.heap32[r10 + numDefine9];
                    r11 = heapClassInst.heap32[r0 + numDefine6];
                    r12 = sp + numDefineNeg176;
                    heapClassInst.heap32[g0] = r9;
                    r9 = r12 >> numDefine2;
                    functionTable[r10 >> numDefine2](i7);
                    r13 = 1;
                    heapClassInst.heap32[r9 + 1] = numDefine53216;
                    r14 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
                    heapClassInst.heap16[(sp + numDefineNeg168) >> 1] = r13;
                    r13 = (r14 + numDefine8) | 0;
                    heapClassInst.heap16[(sp + numDefineNeg166) >> 1] = r15;
                    heapClassInst.heap32[fp + numDefineNeg44] = r13;
                    heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r4 + numDefine13];
                    heapClassInst.heap32[r9 + numDefine4] = heapClassInst.heap32[r4 + numDefine14];
                    heapClassInst.heap32[r9 + numDefine5] = heapClassInst.heap32[r4 + numDefine15];
                    heapClassInst.heap32[r9 + numDefine6] = heapClassInst.heap32[r4 + numDefine16];
                    heapClassInst.heap32[r9 + numDefine7] = heapClassInst.heap32[r8 + numDefine12];
                    heapClassInst.heap32[r9 + numDefine8] = heapClassInst.heap32[r8 + numDefine13];
                    heapClassInst.heap32[r9 + numDefine9] = heapClassInst.heap32[r8 + numDefine14];
                    r14 = ztv34btClosestNotMeConvexResultCallback;
                    heapClassInst.heap32[r9 + numDefine10] = heapClassInst.heap32[r8 + numDefine15];
                    r8 = (r14 + numDefine8) | 0;
                    heapClassInst.heap32[r9 + numDefine19] = 0;
                    heapClassInst.heap32[fp + numDefineNeg44] = r8;
                    heapClassInst.heap32[r9 + numDefine20] = r3;
                    heapClassInst.heap32[r9 + numDefine21] = 0;
                    heapClassInst.heap32[r9 + numDefine22] = commonVariable.rg0;
                    r8 = sp + numDefineNeg232;
                    heapClassInst.heap32[r9 + numDefine23] = r11;
                    r10 = r8 >> numDefine2;
                    f1 = heapClassInst.heapFloat[r4 + numDefine61];
                    heapClassInst.heap32[r10 + numDefine2] = 0;
                    heapClassInst.heap32[r10 + numDefine3] = numDefine53216;
                    heapClassInst.heap32[r10 + numDefine4] = numDefine53216;
                    r11 = ztv13btSphereShape;
                    heapClassInst.heap32[r10 + numDefine5] = numDefine53216;
                    r11 = (r11 + numDefine8) | 0;
                    heapClassInst.heap32[r10 + numDefine6] = 0;
                    heapClassInst.heap32[fp + numDefineNeg58] = r11;
                    heapClassInst.heap32[r10 + 1] = numDefine8;
                    heapClassInst.heapFloat[r10 + numDefine7] = f1;
                    heapClassInst.heapFloat[r10 + numDefine11] = f1;
                    r10 = heapClassInst.heap32[r4 + numDefine47];
                    r10 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
                    heapClassInst.heap16[(sp + numDefineNeg168) >> 1] = r10;
                    r10 = heapClassInst.heap32[r4 + numDefine47];
                    r10 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
                    heapClassInst.heap16[(sp + numDefineNeg166) >> 1] = r10;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r8;
                    heapClassInst.heap32[g0 + numDefine2] = r6;
                    heapClassInst.heap32[g0 + numDefine3] = r7;
                    heapClassInst.heap32[g0 + numDefine4] = r12;
                    heapClassInst.heap32[g0 + numDefine5] = 0;
                    znk16btCollisionWorld15convexSweepTestEPK13btConvexShapeRK11btTransformS5RNS20ConvexResultCallbackEf(i7);
                    f1 = heapClassInst.heapFloat[r9 + 1];
                    f2 = 1;
                    if (!(f1 >= f2)) {
                      heapClassInst.heapFloat[r4 + numDefine60] = f1;
                      f2 = heapClassInst.heapFloat[r4 + numDefine76];
                      f3 = heapClassInst.heapFloat[r4 + numDefine77];
                      f4 = heapClassInst.heapFloat[r4 + numDefine78];
                      f1 = f1 * f0;
                      heapClassInst.heap32[g0] = r6;
                      heapClassInst.heapFloat[g0 + 1] = f2;
                      heapClassInst.heapFloat[g0 + numDefine2] = f3;
                      heapClassInst.heapFloat[g0 + numDefine3] = f4;
                      heapClassInst.heap32[g0 + numDefine4] = r5;
                      heapClassInst.heapFloat[g0 + numDefine5] = f1;
                      heapClassInst.heap32[g0 + numDefine6] = r7;
                      zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                      heapClassInst.heap32[r4 + numDefine60] = 0;
                    }
                    r4 = ztv13btConvexShape;
                    r4 = (r4 + numDefine8) | 0;
                    heapClassInst.heap32[fp + numDefineNeg58] = r4;
                    heapClassInst.heap32[fp + numDefineNeg44] = r13;
                  }
                  r4 = zn15CProfileManager11CurrentNodeE;
                  r4 = r4 >> numDefine2;
                  r5 = heapClassInst.heap32[r4];
                  r6 = r5 >> numDefine2;
                  r8 = heapClassInst.heap32[r6 + numDefine4];
                  r8 = (r8 + -1) | 0;
                  heapClassInst.heap32[r6 + numDefine4] = r8;
                  if (!(r8 !== 0)) {
                    r8 = heapClassInst.heap32[r6 + 1];
                    if (r8 !== 0) {
                      r5 = sp + numDefineNeg8;
                      heapClassInst.heap32[g0] = r5;
                      heapClassInst.heap32[g0 + 1] = 0;
                      r8 = zl13gProfileClock2E0;
                      getTimeOfDay(i7);
                      r8 = r8 >> numDefine2;
                      r8 = heapClassInst.heap32[r8];
                      r8 = r8 >> numDefine2;
                      r5 = r5 >> numDefine2;
                      r9 = heapClassInst.heap32[fp + numDefineNeg2];
                      r10 = heapClassInst.heap32[r8];
                      r9 = (r9 - r10) | 0;
                      r5 = heapClassInst.heap32[r5 + 1];
                      r8 = heapClassInst.heap32[r8 + 1];
                      r5 = (r5 - r8) | 0;
                      r8 = (r9 * numDefineN6) | 0;
                      r5 = (r5 + r8) | 0;
                      r8 = heapClassInst.heap32[r6 + numDefine3];
                      r5 = (r5 - r8) | 0;
                      f1 = uint(r5);
                      f2 = numDefine1000;
                      f3 = heapClassInst.heapFloat[r6 + numDefine2];
                      f1 = f1 / f2;
                      f1 = f3 + f1;
                      heapClassInst.heapFloat[r6 + numDefine2] = f1;
                      r5 = heapClassInst.heap32[r6 + numDefine4];
                      if (r5 !== 0) {
                        break repeat9;
                      } else {
                        r5 = heapClassInst.heap32[r4];
                      }
                    }
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5 + numDefine5];
                    heapClassInst.heap32[r4] = r5;
                  }
                }
              }
            } while (false);
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r7;
            zn11btRigidBody18proceedToTransformERK11btTransform(i7);
          }
        }
      }
      r2 = (r2 + 1) | 0;
      r3 = heapClassInst.heap32[r0 + numDefine52];
      if (r3 > r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat26: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg16;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg4];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat26;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfo(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg168;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr996;
  heapClassInst.heap32[g0] = r0;
  r0 = sp + numDefineNeg48;
  zn15CProfileManager13StartProfileEPKc(i7);
  r1 = 1;
  r2 = r0 >> numDefine2;
  heapClassInst.heap8[sp + numDefineNeg32] = r1;
  heapClassInst.heap32[r2 + numDefine3] = 0;
  r3 = heapClassInst.heap32[fp];
  heapClassInst.heap32[r2 + 1] = 0;
  r4 = r3 >> numDefine2;
  heapClassInst.heap32[r2 + numDefine2] = 0;
  r5 = heapClassInst.heap32[r4 + numDefine47];
  if (!(r5 < 1)) {
    r6 = gNumAlignedAllocs;
    r6 = r6 >> numDefine2;
    r7 = heapClassInst.heap32[r6];
    r8 = r5 << numDefine2;
    r7 = (r7 + 1) | 0;
    r8 = r8 | numDefine3;
    heapClassInst.heap32[r6] = r7;
    r6 = (r8 + numDefine16) | 0;
    heapClassInst.heap32[g0] = r6;
    mallocNew(i7);
    r6 = commonVariable.rg0;
    if (r6 !== 0) {
      r7 = 0;
      r8 = (r6 + numDefine4) | 0;
      r7 = (r7 - r8) | 0;
      r7 = r7 & numDefine15;
      r7 = (r6 + r7) | 0;
      r8 = (r7 + numDefine4) | 0;
      r7 = r7 >> numDefine2;
      heapClassInst.heap32[r7] = r6;
      r6 = r8;
    }
    r7 = 1;
    heapClassInst.heap8[sp + numDefineNeg32] = r7;
    r7 = (r7 - r5) | 0;
    r8 = 0;
    heapClassInst.heap32[r2 + numDefine3] = r6;
    heapClassInst.heap32[r2 + numDefine2] = r5;
    repeat6: while (true) {
      r9 = r8 << numDefine2;
      r6 = (r6 - r9) | 0;
      r6 = r6 >> numDefine2;
      heapClassInst.heap32[r6] = 0;
      if (r7 === r8) {
        break repeat6;
      } else {
        r6 = heapClassInst.heap32[r2 + numDefine3];
        r8 = (r8 + -1) | 0;
        continue repeat6;
      }
    }
  }
  heapClassInst.heap32[r2 + 1] = r5;
  r5 = heapClassInst.heap32[r4];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine24];
  heapClassInst.heap32[g0] = r3;
  functionTable[r5 >> numDefine2](i7);
  r5 = commonVariable.rg0;
  repeat10: do {
    if (!(r5 < 1)) {
      r5 = 0;
      repeat12: while (true) {
        r6 = r5 << numDefine2;
        r7 = heapClassInst.heap32[r4 + numDefine49];
        r7 = (r7 + r6) | 0;
        r7 = r7 >> numDefine2;
        r8 = heapClassInst.heap32[r2 + numDefine3];
        r6 = (r8 + r6) | 0;
        r7 = heapClassInst.heap32[r7];
        r6 = r6 >> numDefine2;
        heapClassInst.heap32[r6] = r7;
        r6 = heapClassInst.heap32[r4];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine24];
        r5 = (r5 + 1) | 0;
        heapClassInst.heap32[g0] = r3;
        functionTable[r6 >> numDefine2](i7);
        r6 = commonVariable.rg0;
        if (r6 > r5) {
          continue repeat12;
        } else {
          break repeat10;
        }
      }
    }
  } while (false);
  r5 = heapClassInst.heap32[r2 + 1];
  if (!(r5 < numDefine2)) {
    r5 = (r5 + -1) | 0;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = 0;
    heapClassInst.heap32[g0 + numDefine2] = r5;
    zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi(i7);
  }
  r0 = heapClassInst.heap32[fp + 1];
  r5 = heapClassInst.heap32[r4];
  r5 = r5 >> numDefine2;
  r5 = heapClassInst.heap32[r5 + numDefine24];
  heapClassInst.heap32[g0] = r3;
  functionTable[r5 >> numDefine2](i7);
  r3 = commonVariable.rg0;
  if (r3 !== 0) {
    r3 = heapClassInst.heap32[r2 + numDefine3];
  } else {
    r3 = 0;
  }
  r5 = heapClassInst.heap32[r4 + numDefine6];
  r6 = heapClassInst.heap32[r4 + numDefine44];
  r7 = ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback;
  r8 = heapClassInst.heap32[r4 + numDefine19];
  r9 = heapClassInst.heap32[r4 + numDefine21];
  r10 = heapClassInst.heap32[r2 + 1];
  r11 = sp + numDefineNeg144;
  r7 = (r7 + numDefine8) | 0;
  r12 = r11 >> numDefine2;
  heapClassInst.heap32[fp + numDefineNeg36] = r7;
  heapClassInst.heap32[r12 + 1] = r0;
  heapClassInst.heap32[r12 + numDefine2] = r6;
  heapClassInst.heap32[r12 + numDefine3] = r3;
  heapClassInst.heap32[r12 + numDefine4] = r10;
  heapClassInst.heap32[r12 + numDefine5] = r9;
  heapClassInst.heap32[r12 + numDefine6] = r8;
  heapClassInst.heap32[r12 + numDefine7] = r5;
  heapClassInst.heap8[sp + numDefineNeg96] = r1;
  heapClassInst.heap32[r12 + numDefine11] = 0;
  heapClassInst.heap32[r12 + numDefine9] = 0;
  heapClassInst.heap32[r12 + numDefine10] = 0;
  heapClassInst.heap8[sp + numDefineNeg76] = r1;
  heapClassInst.heap32[r12 + numDefine16] = 0;
  heapClassInst.heap32[r12 + numDefine14] = 0;
  heapClassInst.heap32[r12 + numDefine15] = 0;
  heapClassInst.heap8[sp + numDefineNeg56] = r1;
  heapClassInst.heap32[r12 + numDefine21] = 0;
  heapClassInst.heap32[r12 + numDefine19] = 0;
  r3 = r6 >> numDefine2;
  heapClassInst.heap32[r12 + numDefine20] = 0;
  r6 = r5 >> numDefine2;
  r3 = heapClassInst.heap32[r3];
  r6 = heapClassInst.heap32[r6];
  r3 = r3 >> numDefine2;
  r6 = r6 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine2];
  r6 = heapClassInst.heap32[r6 + numDefine9];
  heapClassInst.heap32[g0] = r5;
  functionTable[r6 >> numDefine2](i7);
  r6 = heapClassInst.heap32[r4 + numDefine2];
  r8 = heapClassInst.heap32[r4 + numDefine44];
  heapClassInst.heap32[g0] = r8;
  heapClassInst.heap32[g0 + 1] = r6;
  heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
  functionTable[r3 >> numDefine2](i7);
  r3 = heapClassInst.heap32[r4 + numDefine45];
  r5 = heapClassInst.heap32[r4 + numDefine6];
  r6 = twoEStr155;
  heapClassInst.heap32[g0] = r6;
  r6 = r3 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r8 = heapClassInst.heap32[r6 + numDefine7];
  repeat22: do {
    if (!(r8 > -1)) {
      r9 = heapClassInst.heap32[r6 + numDefine8];
      if (!(r9 > -1)) {
        r9 = heapClassInst.heap32[r6 + numDefine9];
        if (!(r9 === 0)) {
          r10 = heapClassInst.heapU8[r3 + numDefine40];
          if (!(r10 === 0)) {
            r10 = gNumAlignedFree;
            r10 = r10 >> numDefine2;
            r13 = heapClassInst.heap32[r10];
            r13 = (r13 + 1) | 0;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r10] = r13;
            r9 = heapClassInst.heap32[r9 + -1];
            heapClassInst.heap32[g0] = r9;
            free(i7);
          }
          heapClassInst.heap32[r6 + numDefine9] = 0;
        }
        r9 = 1;
        heapClassInst.heap8[r3 + numDefine40] = r9;
        heapClassInst.heap32[r6 + numDefine9] = 0;
        heapClassInst.heap32[r6 + numDefine8] = 0;
      }
      repeat32: while (true) {
        r9 = r8 << numDefine2;
        r10 = heapClassInst.heap32[r6 + numDefine9];
        r9 = (r10 + r9) | 0;
        r8 = (r8 + 1) | 0;
        r9 = r9 >> numDefine2;
        heapClassInst.heap32[r9] = 0;
        if (r8 !== 0) {
          continue repeat32;
        } else {
          break repeat22;
        }
      }
    }
  } while (false);
  heapClassInst.heap32[r6 + numDefine7] = 0;
  r8 = heapClassInst.heap32[r6 + numDefine2];
  if (r8 > 0) {
    r9 = 0;
    repeat37: while (true) {
      r10 = heapClassInst.heap32[r6 + numDefine4];
      r13 = r9 << numDefine3;
      r13 = (r10 + r13) | 0;
      r13 = r13 >> numDefine2;
      r13 = heapClassInst.heap32[r13];
      r14 = r9 << 1;
      if (r9 === r13) {
        r16 = r9;
      } else {
        r15 = r10;
        r16 = r9;
        repeat42: while (true) {
          r13 = r13 << numDefine3;
          r16 = r16 << numDefine3;
          r13 = (r15 + r13) | 0;
          r15 = (r15 + r16) | 0;
          r13 = r13 >> numDefine2;
          r15 = r15 >> numDefine2;
          r16 = heapClassInst.heap32[r13];
          heapClassInst.heap32[r15] = r16;
          r16 = heapClassInst.heap32[r13];
          r15 = heapClassInst.heap32[r6 + numDefine4];
          r13 = r16 << numDefine3;
          r13 = (r15 + r13) | 0;
          r13 = r13 >> numDefine2;
          r13 = heapClassInst.heap32[r13];
          if (!(r13 !== r16)) {
            break repeat42;
          }
        }
      }
      r13 = r14 << numDefine2;
      r10 = (r10 + r13) | 0;
      r9 = (r9 + 1) | 0;
      r10 = r10 >> numDefine2;
      heapClassInst.heap32[r10] = r16;
      if (!(r8 !== r9)) {
        break repeat37;
      }
    }
    r8 = heapClassInst.heap32[r6 + numDefine2];
    if (r8 > 1) {
      r9 = (r3 + numDefine4) | 0;
      r8 = (r8 + -1) | 0;
      heapClassInst.heap32[g0] = r9;
      heapClassInst.heap32[g0 + 1] = 0;
      heapClassInst.heap32[g0 + numDefine2] = r8;
      zn20btAlignedObjectArrayI9btElementE17quickSortInternalI31btUnionFindElementSortPredicateEEvTIi(i7);
      r8 = heapClassInst.heap32[r6 + numDefine2];
    }
  }
  r9 = 0;
  repeat48: while (true) {
    r10 = r9;
    if (r10 < r8) {
      r13 = heapClassInst.heap32[r6 + numDefine4];
      r9 = r10 << numDefine3;
      r9 = (r13 + r9) | 0;
      r9 = r9 >> numDefine2;
      r14 = heapClassInst.heap32[r9];
      r15 = (r10 + 1) | 0;
      repeat51: while (true) {
        r9 = r15;
        if (r9 >= r8) {
          break repeat51;
        } else {
          r15 = r9 << numDefine3;
          r15 = (r13 + r15) | 0;
          r16 = r15 >> numDefine2;
          r15 = (r9 + 1) | 0;
          r16 = heapClassInst.heap32[r16];
          if (!(r16 === r14)) {
            break repeat51;
          }
        }
      }
      r16 = 1;
      r15 = r10;
      repeat55: while (true) {
        if (r15 < r9) {
          r17 = r15 << numDefine3;
          r17 = (r13 + r17) | 0;
          r17 = r17 >> numDefine2;
          r17 = heapClassInst.heap32[r17 + 1];
          r18 = heapClassInst.heap32[r4 + numDefine4];
          r17 = r17 << numDefine2;
          r17 = (r18 + r17) | 0;
          r17 = r17 >> numDefine2;
          r17 = heapClassInst.heap32[r17];
          r17 = r17 >> numDefine2;
          r18 = heapClassInst.heap32[r17 + numDefine52];
          if (r18 === r14) {
            r17 = heapClassInst.heap32[r17 + numDefine54];
            r18 = 0;
            if (r17 === numDefine4) {
              r16 = r18;
            } else {
              r16 = r17 === 1 ? r18 : r16;
            }
          } else {
            if (r18 !== -1) {
              label = numDefine37;
              break repeat48;
            }
          }
          r15 = (r15 + 1) | 0;
        } else {
          break repeat55;
        }
      }
      r13 = r16 & numDefine255;
      if (r13 === 0) {
        repeat67: while (true) {
          if (r10 < r9) {
            r13 = heapClassInst.heap32[r6 + numDefine4];
            r15 = r10 << numDefine3;
            r13 = (r13 + r15) | 0;
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13 + 1];
            r15 = heapClassInst.heap32[r4 + numDefine4];
            r13 = r13 << numDefine2;
            r13 = (r15 + r13) | 0;
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13];
            r13 = r13 >> numDefine2;
            r15 = heapClassInst.heap32[r13 + numDefine52];
            if (r15 === r14) {
              r15 = heapClassInst.heap32[r13 + numDefine54];
              if (!(r15 !== numDefine2)) {
                heapClassInst.heap32[r13 + numDefine54] = numDefine3;
                heapClassInst.heap32[r13 + numDefine55] = 0;
              }
            } else {
              if (!(r15 === -1)) {
                label = numDefine54;
                break repeat48;
              }
            }
            r10 = (r10 + 1) | 0;
            continue repeat67;
          } else {
            continue repeat48;
          }
        }
      } else {
        repeat75: while (true) {
          if (r10 < r9) {
            r13 = heapClassInst.heap32[r6 + numDefine4];
            r15 = r10 << numDefine3;
            r13 = (r13 + r15) | 0;
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13 + 1];
            r15 = heapClassInst.heap32[r4 + numDefine4];
            r13 = r13 << numDefine2;
            r13 = (r15 + r13) | 0;
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13];
            r13 = r13 >> numDefine2;
            r15 = heapClassInst.heap32[r13 + numDefine52];
            if (r15 === r14) {
              r15 = heapClassInst.heap32[r13 + numDefine54];
              r15 = (r15 + numDefineNeg4) | 0;
              if (!(uint(r15) < uint(numDefine2))) {
                heapClassInst.heap32[r13 + numDefine54] = numDefine2;
              }
            } else {
              if (!(r15 === -1)) {
                label = numDefine47;
                break repeat48;
              }
            }
            r10 = (r10 + 1) | 0;
            continue repeat75;
          } else {
            continue repeat48;
          }
        }
      }
    } else {
      label = numDefine60;
      break repeat48;
    }
  }
  switch (label) {
    case numDefine37:
      r0 = twoEStr1156;
      r1 = twoEStr2157;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine242;
      assertNew(i7);
      break;
    case numDefine54:
      r0 = twoEStr1156;
      r1 = twoEStr2157;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine290;
      assertNew(i7);
      break;
    case numDefine60:
      r8 = r5 >> numDefine2;
      r9 = heapClassInst.heap32[r8];
      r9 = r9 >> numDefine2;
      r9 = heapClassInst.heap32[r9 + numDefine9];
      heapClassInst.heap32[g0] = r5;
      functionTable[r9 >> numDefine2](i7);
      r9 = commonVariable.rg0;
      repeat87: do {
        if (!(r9 < 1)) {
          r10 = 0;
          repeat89: while (true) {
            r13 = heapClassInst.heap32[r8];
            r13 = r13 >> numDefine2;
            r13 = heapClassInst.heap32[r13 + numDefine10];
            heapClassInst.heap32[g0] = r5;
            heapClassInst.heap32[g0 + 1] = r10;
            functionTable[r13 >> numDefine2](i7);
            r13 = commonVariable.rg0;
            r14 = r13 >> numDefine2;
            r15 = heapClassInst.heap32[r14 + numDefine277];
            r14 = heapClassInst.heap32[r14 + numDefine278];
            if (r15 === 0) {
              label = numDefine64;
            } else {
              r16 = r15 >> numDefine2;
              r16 = heapClassInst.heap32[r16 + numDefine54];
              if (r16 !== numDefine2) {
                label = numDefine66;
              } else {
                label = numDefine64;
              }
            }
            if (label === numDefine64) {
              if (r14 === 0) {
                label = numDefine95;
              } else {
                r16 = r14 >> numDefine2;
                r16 = heapClassInst.heap32[r16 + numDefine54];
                if (r16 === numDefine2) {
                  label = numDefine95;
                } else {
                  label = numDefine66;
                }
              }
            }
            if (label === numDefine66) {
              r16 = heapClassInst.heapU8[r15 + numDefine204];
              r16 = r16 & numDefine2;
              if (!(r16 === 0)) {
                r16 = r15 >> numDefine2;
                r16 = heapClassInst.heap32[r16 + numDefine54];
                if (!(r16 === numDefine2)) {
                  r16 = heapClassInst.heapU8[r14 + numDefine204];
                  r16 = r16 & numDefine3;
                  if (!(r16 !== 0)) {
                    r16 = r14 >> numDefine2;
                    r17 = heapClassInst.heap32[r16 + numDefine54];
                    r17 = (r17 + numDefineNeg4) | 0;
                    if (!(uint(r17) < uint(numDefine2))) {
                      heapClassInst.heap32[r16 + numDefine54] = 1;
                    }
                    heapClassInst.heap32[r16 + numDefine55] = 0;
                  }
                }
              }
              r16 = heapClassInst.heapU8[r14 + numDefine204];
              r16 = r16 & numDefine2;
              if (!(r16 === 0)) {
                r16 = r14 >> numDefine2;
                r16 = heapClassInst.heap32[r16 + numDefine54];
                if (!(r16 === numDefine2)) {
                  r16 = heapClassInst.heapU8[r15 + numDefine204];
                  r16 = r16 & numDefine3;
                  if (!(r16 !== 0)) {
                    r16 = r15 >> numDefine2;
                    r17 = heapClassInst.heap32[r16 + numDefine54];
                    r17 = (r17 + numDefineNeg4) | 0;
                    if (!(uint(r17) < uint(numDefine2))) {
                      heapClassInst.heap32[r16 + numDefine54] = 1;
                    }
                    heapClassInst.heap32[r16 + numDefine55] = 0;
                  }
                }
              }
              r16 = heapClassInst.heapU8[r3 + numDefine64];
              if (!(r16 === 0)) {
                r16 = heapClassInst.heap32[r8];
                r16 = r16 >> numDefine2;
                r16 = heapClassInst.heap32[r16 + numDefine7];
                heapClassInst.heap32[g0] = r5;
                heapClassInst.heap32[g0 + 1] = r15;
                heapClassInst.heap32[g0 + numDefine2] = r14;
                functionTable[r16 >> numDefine2](i7);
                r14 = commonVariable.rg0;
                if (!(r14 === 0)) {
                  r14 = heapClassInst.heap32[r6 + numDefine8];
                  r15 = heapClassInst.heap32[r6 + numDefine7];
                  if (r14 === r15) {
                    r16 = 1;
                    r17 = r15 << 1;
                    r17 = r15 === 0 ? r16 : r17;
                    if (!(r14 >= r17)) {
                      if (r17 !== 0) {
                        r14 = gNumAlignedAllocs;
                        r14 = r14 >> numDefine2;
                        r18 = heapClassInst.heap32[r14];
                        r19 = r17 << numDefine2;
                        r18 = (r18 + 1) | 0;
                        r19 = r19 | numDefine3;
                        heapClassInst.heap32[r14] = r18;
                        r14 = (r19 + numDefine16) | 0;
                        heapClassInst.heap32[g0] = r14;
                        mallocNew(i7);
                        r14 = commonVariable.rg0;
                        if (r14 !== 0) {
                          r15 = 0;
                          r18 = (r14 + numDefine4) | 0;
                          r15 = (r15 - r18) | 0;
                          r15 = r15 & numDefine15;
                          r15 = (r14 + r15) | 0;
                          r18 = r15 >> numDefine2;
                          heapClassInst.heap32[r18] = r14;
                          r14 = (r15 + numDefine4) | 0;
                          r15 = heapClassInst.heap32[r6 + numDefine7];
                        }
                      } else {
                        r14 = 0;
                      }
                      if (!(r15 < 1)) {
                        r18 = 0;
                        repeat126: while (true) {
                          r19 = r18 << numDefine2;
                          r20 = heapClassInst.heap32[r6 + numDefine9];
                          r20 = (r20 + r19) | 0;
                          r20 = r20 >> numDefine2;
                          r19 = (r14 + r19) | 0;
                          r20 = heapClassInst.heap32[r20];
                          r18 = (r18 + 1) | 0;
                          r19 = r19 >> numDefine2;
                          heapClassInst.heap32[r19] = r20;
                          if (!(r15 !== r18)) {
                            break repeat126;
                          }
                        }
                      }
                      r15 = heapClassInst.heap32[r6 + numDefine9];
                      if (!(r15 === 0)) {
                        r18 = heapClassInst.heapU8[r3 + numDefine40];
                        if (!(r18 === 0)) {
                          r18 = gNumAlignedFree;
                          r18 = r18 >> numDefine2;
                          r19 = heapClassInst.heap32[r18];
                          r19 = (r19 + 1) | 0;
                          r15 = r15 >> numDefine2;
                          heapClassInst.heap32[r18] = r19;
                          r15 = heapClassInst.heap32[r15 + -1];
                          heapClassInst.heap32[g0] = r15;
                          free(i7);
                        }
                        heapClassInst.heap32[r6 + numDefine9] = 0;
                      }
                      heapClassInst.heap8[r3 + numDefine40] = r16;
                      heapClassInst.heap32[r6 + numDefine9] = r14;
                      heapClassInst.heap32[r6 + numDefine8] = r17;
                      r15 = heapClassInst.heap32[r6 + numDefine7];
                    }
                  }
                  r14 = r15 << numDefine2;
                  r15 = heapClassInst.heap32[r6 + numDefine9];
                  r14 = (r15 + r14) | 0;
                  r14 = r14 >> numDefine2;
                  heapClassInst.heap32[r14] = r13;
                  r13 = heapClassInst.heap32[r6 + numDefine7];
                  r13 = (r13 + 1) | 0;
                  heapClassInst.heap32[r6 + numDefine7] = r13;
                }
              }
            }
            r10 = (r10 + 1) | 0;
            if (r9 !== r10) {
              continue repeat89;
            } else {
              break repeat87;
            }
          }
        }
      } while (false);
      r9 = zn15CProfileManager11CurrentNodeE;
      r9 = r9 >> numDefine2;
      r10 = heapClassInst.heap32[r9];
      r13 = r10 >> numDefine2;
      r14 = heapClassInst.heap32[r13 + numDefine4];
      r14 = (r14 + -1) | 0;
      heapClassInst.heap32[r13 + numDefine4] = r14;
      repeat138: do {
        if (!(r14 !== 0)) {
          r14 = heapClassInst.heap32[r13 + 1];
          if (r14 !== 0) {
            r10 = sp + numDefineNeg24;
            heapClassInst.heap32[g0] = r10;
            heapClassInst.heap32[g0 + 1] = 0;
            r14 = zl13gProfileClock2E0;
            getTimeOfDay(i7);
            r14 = r14 >> numDefine2;
            r14 = heapClassInst.heap32[r14];
            r14 = r14 >> numDefine2;
            r10 = r10 >> numDefine2;
            r15 = heapClassInst.heap32[fp + numDefineNeg6];
            r16 = heapClassInst.heap32[r14];
            r15 = (r15 - r16) | 0;
            r10 = heapClassInst.heap32[r10 + 1];
            r14 = heapClassInst.heap32[r14 + 1];
            r10 = (r10 - r14) | 0;
            r14 = (r15 * numDefineN6) | 0;
            r10 = (r10 + r14) | 0;
            r14 = heapClassInst.heap32[r13 + numDefine3];
            r10 = (r10 - r14) | 0;
            f0 = uint(r10);
            f1 = numDefine1000;
            f2 = heapClassInst.heapFloat[r13 + numDefine2];
            f0 = f0 / f1;
            f0 = f2 + f0;
            heapClassInst.heapFloat[r13 + numDefine2] = f0;
            r10 = heapClassInst.heap32[r13 + numDefine4];
            if (r10 !== 0) {
              break repeat138;
            } else {
              r10 = heapClassInst.heap32[r9];
            }
          }
          r10 = r10 >> numDefine2;
          r10 = heapClassInst.heap32[r10 + numDefine5];
          heapClassInst.heap32[r9] = r10;
        }
      } while (false);
      r10 = heapClassInst.heap32[r6 + numDefine2];
      r13 = twoEStr3158;
      heapClassInst.heap32[g0] = r13;
      zn15CProfileManager13StartProfileEPKc(i7);
      r13 = heapClassInst.heapU8[r3 + numDefine64];
      repeat145: do {
        if (r13 !== 0) {
          r5 = heapClassInst.heap32[r6 + numDefine7];
          if (!(r5 < numDefine2)) {
            r8 = (r3 + numDefine24) | 0;
            r13 = (r5 + -1) | 0;
            heapClassInst.heap32[g0] = r8;
            heapClassInst.heap32[g0 + 1] = 0;
            heapClassInst.heap32[g0 + numDefine2] = r13;
            zn20btAlignedObjectArrayIP20btPersistentManifoldE17quickSortInternalI33btPersistentManifoldSortPredicateEEvTIi(i7);
          }
          if (!(r10 < 1)) {
            r8 = 0;
            r13 = r8;
            r14 = r8;
            repeat151: while (true) {
              r15 = heapClassInst.heap32[r6 + numDefine4];
              r16 = r14 << numDefine3;
              r15 = (r15 + r16) | 0;
              r15 = r15 >> numDefine2;
              r15 = heapClassInst.heap32[r15];
              r16 = r8;
              repeat153: while (true) {
                if (r14 >= r10) {
                  break repeat153;
                } else {
                  r17 = heapClassInst.heap32[r6 + numDefine4];
                  r18 = r14 << numDefine3;
                  r17 = (r17 + r18) | 0;
                  r17 = r17 >> numDefine2;
                  r18 = heapClassInst.heap32[r17];
                  if (r18 === r15) {
                    r17 = heapClassInst.heap32[r17 + 1];
                    r18 = heapClassInst.heap32[r4 + numDefine4];
                    r17 = r17 << numDefine2;
                    r17 = (r18 + r17) | 0;
                    r17 = r17 >> numDefine2;
                    r18 = heapClassInst.heap32[r6 + numDefine13];
                    r19 = heapClassInst.heap32[r6 + numDefine12];
                    r17 = heapClassInst.heap32[r17];
                    if (r18 === r19) {
                      r20 = 1;
                      r21 = r19 << 1;
                      r21 = r19 === 0 ? r20 : r21;
                      if (!(r18 >= r21)) {
                        if (r21 !== 0) {
                          r18 = gNumAlignedAllocs;
                          r18 = r18 >> numDefine2;
                          r22 = heapClassInst.heap32[r18];
                          r23 = r21 << numDefine2;
                          r22 = (r22 + 1) | 0;
                          r23 = r23 | numDefine3;
                          heapClassInst.heap32[r18] = r22;
                          r18 = (r23 + numDefine16) | 0;
                          heapClassInst.heap32[g0] = r18;
                          mallocNew(i7);
                          r18 = commonVariable.rg0;
                          if (r18 !== 0) {
                            r19 = 0;
                            r22 = (r18 + numDefine4) | 0;
                            r19 = (r19 - r22) | 0;
                            r19 = r19 & numDefine15;
                            r19 = (r18 + r19) | 0;
                            r22 = r19 >> numDefine2;
                            heapClassInst.heap32[r22] = r18;
                            r18 = (r19 + numDefine4) | 0;
                            r19 = heapClassInst.heap32[r6 + numDefine12];
                          }
                        } else {
                          r18 = 0;
                        }
                        if (!(r19 < 1)) {
                          r22 = 0;
                          repeat167: while (true) {
                            r23 = r22 << numDefine2;
                            r24 = heapClassInst.heap32[r6 + numDefine14];
                            r24 = (r24 + r23) | 0;
                            r24 = r24 >> numDefine2;
                            r23 = (r18 + r23) | 0;
                            r24 = heapClassInst.heap32[r24];
                            r22 = (r22 + 1) | 0;
                            r23 = r23 >> numDefine2;
                            heapClassInst.heap32[r23] = r24;
                            if (!(r19 !== r22)) {
                              break repeat167;
                            }
                          }
                        }
                        r19 = heapClassInst.heap32[r6 + numDefine14];
                        if (!(r19 === 0)) {
                          r22 = heapClassInst.heapU8[r3 + numDefine60];
                          if (!(r22 === 0)) {
                            r22 = gNumAlignedFree;
                            r22 = r22 >> numDefine2;
                            r23 = heapClassInst.heap32[r22];
                            r23 = (r23 + 1) | 0;
                            r19 = r19 >> numDefine2;
                            heapClassInst.heap32[r22] = r23;
                            r19 = heapClassInst.heap32[r19 + -1];
                            heapClassInst.heap32[g0] = r19;
                            free(i7);
                          }
                          heapClassInst.heap32[r6 + numDefine14] = 0;
                        }
                        heapClassInst.heap8[r3 + numDefine60] = r20;
                        heapClassInst.heap32[r6 + numDefine14] = r18;
                        heapClassInst.heap32[r6 + numDefine13] = r21;
                        r19 = heapClassInst.heap32[r6 + numDefine12];
                      }
                    }
                    r18 = r19 << numDefine2;
                    r19 = heapClassInst.heap32[r6 + numDefine14];
                    r18 = (r19 + r18) | 0;
                    r18 = r18 >> numDefine2;
                    heapClassInst.heap32[r18] = r17;
                    r18 = heapClassInst.heap32[r6 + numDefine12];
                    r18 = (r18 + 1) | 0;
                    r17 = r17 >> numDefine2;
                    heapClassInst.heap32[r6 + numDefine12] = r18;
                    r17 = heapClassInst.heap32[r17 + numDefine54];
                    if (r17 !== numDefine2) {
                      r18 = 1;
                      r16 = r17 === numDefine5 ? r18 : r16;
                    } else {
                      r16 = 1;
                    }
                    r14 = (r14 + 1) | 0;
                  } else {
                    break repeat153;
                  }
                }
              }
              repeat182: do {
                if (r13 < r5) {
                  r17 = heapClassInst.heap32[r6 + numDefine9];
                  r19 = r13 << numDefine2;
                  r18 = (r17 + r19) | 0;
                  r20 = r18 >> numDefine2;
                  r20 = heapClassInst.heap32[r20];
                  r20 = r20 >> numDefine2;
                  r21 = heapClassInst.heap32[r20 + numDefine277];
                  r21 = r21 >> numDefine2;
                  r21 = heapClassInst.heap32[r21 + numDefine52];
                  if (r21 < 0) {
                    r21 = heapClassInst.heap32[r20 + numDefine278];
                    r21 = r21 >> numDefine2;
                    r21 = heapClassInst.heap32[r21 + numDefine52];
                  }
                  if (r21 !== r15) {
                    label = numDefine129;
                  } else {
                    r19 = (r17 + r19) | 0;
                    r20 = 1;
                    while (true) {
                      r17 = r20;
                      r1 = (r13 + r17) | 0;
                      if (r1 >= r5) {
                        label = numDefine138;
                        break repeat182;
                      } else {
                        r20 = r17 << numDefine2;
                        r20 = (r19 + r20) | 0;
                        r20 = r20 >> numDefine2;
                        r20 = heapClassInst.heap32[r20];
                        r20 = r20 >> numDefine2;
                        r21 = heapClassInst.heap32[r20 + numDefine277];
                        r21 = r21 >> numDefine2;
                        r21 = heapClassInst.heap32[r21 + numDefine52];
                        if (r21 < 0) {
                          r20 = heapClassInst.heap32[r20 + numDefine278];
                          r20 = r20 >> numDefine2;
                          r21 = heapClassInst.heap32[r20 + numDefine52];
                        }
                        r20 = (r17 + 1) | 0;
                        if (!(r21 === r15)) {
                          label = numDefine138;
                          break repeat182;
                        }
                      }
                    }
                  }
                } else {
                  label = numDefine129;
                }
              } while (false);
              if (label === numDefine129) {
                r17 = 0;
                r18 = r17;
              }
              r16 = r16 & numDefine255;
              if (!(r16 !== 0)) {
                r16 = heapClassInst.heap32[fp + numDefineNeg36];
                r16 = r16 >> numDefine2;
                r16 = heapClassInst.heap32[r16 + numDefine2];
                r19 = heapClassInst.heap32[r6 + numDefine12];
                r20 = heapClassInst.heap32[r6 + numDefine14];
                heapClassInst.heap32[g0] = r11;
                heapClassInst.heap32[g0 + 1] = r20;
                heapClassInst.heap32[g0 + numDefine2] = r19;
                heapClassInst.heap32[g0 + numDefine3] = r18;
                heapClassInst.heap32[g0 + numDefine4] = r17;
                heapClassInst.heap32[g0 + numDefine5] = r15;
                functionTable[r16 >> numDefine2](i7);
              }
              r15 = heapClassInst.heap32[r6 + numDefine12];
              repeat200: do {
                if (!(r15 > -1)) {
                  r16 = heapClassInst.heap32[r6 + numDefine13];
                  if (r16 < 0) {
                    r16 = heapClassInst.heap32[r6 + numDefine14];
                    if (!(r16 === 0)) {
                      r18 = heapClassInst.heapU8[r3 + numDefine60];
                      if (!(r18 === 0)) {
                        r18 = gNumAlignedFree;
                        r18 = r18 >> numDefine2;
                        r19 = heapClassInst.heap32[r18];
                        r19 = (r19 + 1) | 0;
                        r16 = r16 >> numDefine2;
                        heapClassInst.heap32[r18] = r19;
                        r16 = heapClassInst.heap32[r16 + -1];
                        heapClassInst.heap32[g0] = r16;
                        free(i7);
                      }
                      heapClassInst.heap32[r6 + numDefine14] = 0;
                    }
                    r16 = 1;
                    heapClassInst.heap8[r3 + numDefine60] = r16;
                    heapClassInst.heap32[r6 + numDefine14] = 0;
                    heapClassInst.heap32[r6 + numDefine13] = 0;
                  }
                  while (true) {
                    r16 = r15 << numDefine2;
                    r18 = heapClassInst.heap32[r6 + numDefine14];
                    r16 = (r18 + r16) | 0;
                    r15 = (r15 + 1) | 0;
                    r16 = r16 >> numDefine2;
                    heapClassInst.heap32[r16] = 0;
                    if (!(r15 !== 0)) {
                      break repeat200;
                    }
                  }
                }
              } while (false);
              r13 = r17 === 0 ? r13 : r1;
              heapClassInst.heap32[r6 + numDefine12] = 0;
              if (r14 < r10) {
                continue repeat151;
              } else {
                break repeat145;
              }
            }
          }
        } else {
          r1 = heapClassInst.heap32[r8];
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine11];
          heapClassInst.heap32[g0] = r5;
          functionTable[r1 >> numDefine2](i7);
          r1 = commonVariable.rg0;
          r3 = heapClassInst.heap32[r8];
          r3 = r3 >> numDefine2;
          r3 = heapClassInst.heap32[r3 + numDefine9];
          heapClassInst.heap32[g0] = r5;
          functionTable[r3 >> numDefine2](i7);
          r6 = heapClassInst.heap32[fp + numDefineNeg36];
          r6 = r6 >> numDefine2;
          r6 = heapClassInst.heap32[r6 + numDefine2];
          r10 = heapClassInst.heap32[r4 + numDefine2];
          r5 = heapClassInst.heap32[r4 + numDefine4];
          heapClassInst.heap32[g0] = r11;
          heapClassInst.heap32[g0 + 1] = r5;
          heapClassInst.heap32[g0 + numDefine2] = r10;
          heapClassInst.heap32[g0 + numDefine3] = r1;
          heapClassInst.heap32[g0 + numDefine4] = commonVariable.rg0;
          heapClassInst.heap32[g0 + numDefine5] = -1;
          functionTable[r6 >> numDefine2](i7);
        }
      } while (false);
      r1 = heapClassInst.heap32[r9];
      r3 = r1 >> numDefine2;
      r5 = heapClassInst.heap32[r3 + numDefine4];
      r5 = (r5 + -1) | 0;
      heapClassInst.heap32[r3 + numDefine4] = r5;
      repeat215: do {
        if (!(r5 !== 0)) {
          r5 = heapClassInst.heap32[r3 + 1];
          if (r5 !== 0) {
            r1 = sp + numDefineNeg16;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = 0;
            r5 = zl13gProfileClock2E0;
            getTimeOfDay(i7);
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r5 = r5 >> numDefine2;
            r1 = r1 >> numDefine2;
            r6 = heapClassInst.heap32[fp + numDefineNeg4];
            r8 = heapClassInst.heap32[r5];
            r6 = (r6 - r8) | 0;
            r1 = heapClassInst.heap32[r1 + 1];
            r5 = heapClassInst.heap32[r5 + 1];
            r1 = (r1 - r5) | 0;
            r5 = (r6 * numDefineN6) | 0;
            r1 = (r1 + r5) | 0;
            r5 = heapClassInst.heap32[r3 + numDefine3];
            r1 = (r1 - r5) | 0;
            f0 = uint(r1);
            f1 = numDefine1000;
            f2 = heapClassInst.heapFloat[r3 + numDefine2];
            f0 = f0 / f1;
            f0 = f2 + f0;
            heapClassInst.heapFloat[r3 + numDefine2] = f0;
            r1 = heapClassInst.heap32[r3 + numDefine4];
            if (r1 !== 0) {
              break repeat215;
            } else {
              r1 = heapClassInst.heap32[r9];
            }
          }
          r1 = r1 >> numDefine2;
          r1 = heapClassInst.heap32[r1 + numDefine5];
          heapClassInst.heap32[r9] = r1;
        }
      } while (false);
      heapClassInst.heap32[g0] = r11;
      zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallback18processConstraintsEv(i7);
      r1 = heapClassInst.heap32[r4 + numDefine44];
      r3 = r1 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine4];
      r5 = heapClassInst.heap32[r4 + numDefine19];
      r4 = heapClassInst.heap32[r4 + numDefine21];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      heapClassInst.heap32[g0 + numDefine2] = r4;
      heapClassInst.heap32[g0 + numDefine3] = r5;
      functionTable[r3 >> numDefine2](i7);
      heapClassInst.heap32[fp + numDefineNeg36] = r7;
      r0 = heapClassInst.heap32[r12 + numDefine21];
      if (!(r0 === 0)) {
        r1 = heapClassInst.heapU8[sp + numDefineNeg56];
        if (!(r1 === 0)) {
          r1 = gNumAlignedFree;
          r1 = r1 >> numDefine2;
          r3 = heapClassInst.heap32[r1];
          r3 = (r3 + 1) | 0;
          r0 = r0 >> numDefine2;
          heapClassInst.heap32[r1] = r3;
          r0 = heapClassInst.heap32[r0 + -1];
          heapClassInst.heap32[g0] = r0;
          free(i7);
        }
        heapClassInst.heap32[r12 + numDefine21] = 0;
      }
      r0 = 1;
      heapClassInst.heap8[sp + numDefineNeg56] = r0;
      heapClassInst.heap32[r12 + numDefine21] = 0;
      heapClassInst.heap32[r12 + numDefine19] = 0;
      heapClassInst.heap32[r12 + numDefine20] = 0;
      r1 = heapClassInst.heap32[r12 + numDefine16];
      if (!(r1 === 0)) {
        r3 = heapClassInst.heapU8[sp + numDefineNeg76];
        if (!(r3 === 0)) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r4 = heapClassInst.heap32[r3];
          r4 = (r4 + 1) | 0;
          r1 = r1 >> numDefine2;
          heapClassInst.heap32[r3] = r4;
          r1 = heapClassInst.heap32[r1 + -1];
          heapClassInst.heap32[g0] = r1;
          free(i7);
        }
        heapClassInst.heap32[r12 + numDefine16] = 0;
      }
      heapClassInst.heap8[sp + numDefineNeg76] = r0;
      heapClassInst.heap32[r12 + numDefine16] = 0;
      heapClassInst.heap32[r12 + numDefine14] = 0;
      heapClassInst.heap32[r12 + numDefine15] = 0;
      r1 = heapClassInst.heap32[r12 + numDefine11];
      if (!(r1 === 0)) {
        r3 = heapClassInst.heapU8[sp + numDefineNeg96];
        if (!(r3 === 0)) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r4 = heapClassInst.heap32[r3];
          r4 = (r4 + 1) | 0;
          r1 = r1 >> numDefine2;
          heapClassInst.heap32[r3] = r4;
          r1 = heapClassInst.heap32[r1 + -1];
          heapClassInst.heap32[g0] = r1;
          free(i7);
        }
        heapClassInst.heap32[r12 + numDefine11] = 0;
      }
      heapClassInst.heap8[sp + numDefineNeg96] = r0;
      heapClassInst.heap32[r12 + numDefine11] = 0;
      heapClassInst.heap32[r12 + numDefine9] = 0;
      heapClassInst.heap32[r12 + numDefine10] = 0;
      r1 = heapClassInst.heap32[r2 + numDefine3];
      if (!(r1 === 0)) {
        r3 = heapClassInst.heapU8[sp + numDefineNeg32];
        if (!(r3 === 0)) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r4 = heapClassInst.heap32[r3];
          r4 = (r4 + 1) | 0;
          r1 = r1 >> numDefine2;
          heapClassInst.heap32[r3] = r4;
          r1 = heapClassInst.heap32[r1 + -1];
          heapClassInst.heap32[g0] = r1;
          free(i7);
        }
        heapClassInst.heap32[r2 + numDefine3] = 0;
      }
      heapClassInst.heap8[sp + numDefineNeg32] = r0;
      heapClassInst.heap32[r2 + numDefine3] = 0;
      heapClassInst.heap32[r2 + 1] = 0;
      heapClassInst.heap32[r2 + numDefine2] = 0;
      r0 = heapClassInst.heap32[r9];
      r1 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r1 + numDefine4];
      r2 = (r2 + -1) | 0;
      heapClassInst.heap32[r1 + numDefine4] = r2;
      repeat246: do {
        if (!(r2 !== 0)) {
          r2 = heapClassInst.heap32[r1 + 1];
          if (r2 !== 0) {
            r0 = sp + numDefineNeg8;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = 0;
            r2 = zl13gProfileClock2E0;
            getTimeOfDay(i7);
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2];
            r2 = r2 >> numDefine2;
            r0 = r0 >> numDefine2;
            r3 = heapClassInst.heap32[fp + numDefineNeg2];
            r4 = heapClassInst.heap32[r2];
            r3 = (r3 - r4) | 0;
            r0 = heapClassInst.heap32[r0 + 1];
            r2 = heapClassInst.heap32[r2 + 1];
            r0 = (r0 - r2) | 0;
            r2 = (r3 * numDefineN6) | 0;
            r0 = (r0 + r2) | 0;
            r2 = heapClassInst.heap32[r1 + numDefine3];
            r0 = (r0 - r2) | 0;
            f0 = uint(r0);
            f1 = numDefine1000;
            f2 = heapClassInst.heapFloat[r1 + numDefine2];
            f0 = f0 / f1;
            f0 = f2 + f0;
            heapClassInst.heapFloat[r1 + numDefine2] = f0;
            r0 = heapClassInst.heap32[r1 + numDefine4];
            if (r0 !== 0) {
              break repeat246;
            } else {
              r0 = heapClassInst.heap32[r9];
            }
          }
          r0 = r0 >> numDefine2;
          r0 = heapClassInst.heap32[r0 + numDefine5];
          heapClassInst.heap32[r9] = r0;
        }
      } while (false);
      return;
    case numDefine47:
      r0 = twoEStr1156;
      r1 = twoEStr2157;
      heapClassInst.heap32[g0] = r0;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heap32[g0 + numDefine2] = numDefine269;
      assertNew(i7);
      break;
    default:
      break;
  }
}

function zn23btDiscreteDynamicsWorld16removeConstraintEP17btTypedConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[r0 + numDefine47];
  r3 = 0;
  repeat1: while (true) {
    if (r2 > r3) {
      r4 = heapClassInst.heap32[r0 + numDefine49];
      r5 = r3 << numDefine2;
      r4 = (r4 + r5) | 0;
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      if (r4 !== r1) {
        r3 = (r3 + 1) | 0;
        continue repeat1;
      } else {
        label = numDefine5;
        break repeat1;
      }
    } else {
      label = numDefine4;
      break repeat1;
    }
  }
  if (label === numDefine4) {
    r3 = r2;
  }
  if (!(r2 <= r3)) {
    r2 = (r2 + -1) | 0;
    r3 = r3 << numDefine2;
    r4 = heapClassInst.heap32[r0 + numDefine49];
    r2 = r2 << numDefine2;
    r3 = (r4 + r3) | 0;
    r4 = (r4 + r2) | 0;
    r3 = r3 >> numDefine2;
    r4 = r4 >> numDefine2;
    r5 = heapClassInst.heap32[r3];
    r4 = heapClassInst.heap32[r4];
    heapClassInst.heap32[r3] = r4;
    r3 = heapClassInst.heap32[r0 + numDefine49];
    r2 = (r3 + r2) | 0;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[r2] = r5;
    r2 = heapClassInst.heap32[r0 + numDefine47];
    r2 = (r2 + -1) | 0;
    heapClassInst.heap32[r0 + numDefine47] = r2;
  }
  r0 = r1 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + numDefine5];
  r2 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine120];
  r4 = 0;
  repeat11: while (true) {
    if (r3 > r4) {
      r5 = heapClassInst.heap32[r2 + numDefine122];
      r6 = r4 << numDefine2;
      r5 = (r5 + r6) | 0;
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      if (r5 !== r1) {
        r4 = (r4 + 1) | 0;
        continue repeat11;
      } else {
        label = numDefine12;
        break repeat11;
      }
    } else {
      label = numDefine11;
      break repeat11;
    }
  }
  if (label === numDefine11) {
    r4 = r3;
  }
  if (r3 > r4) {
    r3 = (r3 + -1) | 0;
    r4 = r4 << numDefine2;
    r5 = heapClassInst.heap32[r2 + numDefine122];
    r3 = r3 << numDefine2;
    r4 = (r5 + r4) | 0;
    r5 = (r5 + r3) | 0;
    r4 = r4 >> numDefine2;
    r5 = r5 >> numDefine2;
    r6 = heapClassInst.heap32[r4];
    r5 = heapClassInst.heap32[r5];
    heapClassInst.heap32[r4] = r5;
    r4 = heapClassInst.heap32[r2 + numDefine122];
    r3 = (r4 + r3) | 0;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r3] = r6;
    r3 = heapClassInst.heap32[r2 + numDefine120];
    r3 = (r3 + -1) | 0;
    heapClassInst.heap32[r2 + numDefine120] = r3;
  }
  r4 = 0;

  r3 = r3 > r4 ? 1 : 0;
  r3 = r3 & 1;
  heapClassInst.heap32[r2 + numDefine63] = r3;
  r0 = heapClassInst.heap32[r0 + numDefine6];
  r0 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r0 + numDefine120];
  repeat21: while (true) {
    if (r2 > r4) {
      r3 = heapClassInst.heap32[r0 + numDefine122];
      r5 = r4 << numDefine2;
      r3 = (r3 + r5) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      if (r3 !== r1) {
        r4 = (r4 + 1) | 0;
        continue repeat21;
      } else {
        label = numDefine19;
        break repeat21;
      }
    } else {
      label = numDefine18;
      break repeat21;
    }
  }
  if (label === numDefine18) {
    r4 = r2;
  }
  if (r2 > r4) {
    r2 = (r2 + -1) | 0;
    r1 = r4 << numDefine2;
    r3 = heapClassInst.heap32[r0 + numDefine122];
    r2 = r2 << numDefine2;
    r1 = (r3 + r1) | 0;
    r3 = (r3 + r2) | 0;
    r1 = r1 >> numDefine2;
    r3 = r3 >> numDefine2;
    r4 = heapClassInst.heap32[r1];
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[r1] = r3;
    r1 = heapClassInst.heap32[r0 + numDefine122];
    r2 = (r1 + r2) | 0;
    r2 = r2 >> numDefine2;
    heapClassInst.heap32[r2] = r4;
    r2 = heapClassInst.heap32[r0 + numDefine120];
    r2 = (r2 + -1) | 0;
    heapClassInst.heap32[r0 + numDefine120] = r2;
  }
  r1 = 0;

  r1 = r2 > r1 ? 1 : 0;
  r1 = r1 & 1;
  heapClassInst.heap32[r0 + numDefine63] = r1;
  return;
}

function zn23btDiscreteDynamicsWorld13addConstraintEP17btTypedConstraintb(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine48];
  r3 = heapClassInst.heap32[r1 + numDefine47];
  r4 = heapClassInst.heap32[fp + 1];
  r5 = heapClassInst.heap32[fp + numDefine2];
  if (r2 === r3) {
    r6 = 1;
    r7 = r3 << 1;
    r7 = r3 === 0 ? r6 : r7;
    if (!(r2 >= r7)) {
      if (r7 !== 0) {
        r2 = gNumAlignedAllocs;
        r2 = r2 >> numDefine2;
        r8 = heapClassInst.heap32[r2];
        r9 = r7 << numDefine2;
        r8 = (r8 + 1) | 0;
        r9 = r9 | numDefine3;
        heapClassInst.heap32[r2] = r8;
        r2 = (r9 + numDefine16) | 0;
        heapClassInst.heap32[g0] = r2;
        mallocNew(i7);
        r2 = commonVariable.rg0;
        if (r2 !== 0) {
          r8 = 0;
          r9 = (r2 + numDefine4) | 0;
          r8 = (r8 - r9) | 0;
          r8 = r8 & numDefine15;
          r8 = (r2 + r8) | 0;
          r9 = (r8 + numDefine4) | 0;
          r8 = r8 >> numDefine2;
          heapClassInst.heap32[r8] = r2;
          r2 = r9;
        }
      } else {
        r2 = 0;
      }
      r8 = (r0 + numDefine196) | 0;
      if (r3 < 1) {
        r9 = r8 >> numDefine2;
        r10 = heapClassInst.heap32[r9];
      } else {
        r9 = 0;
        repeat12: while (true) {
          r10 = r8 >> numDefine2;
          r10 = heapClassInst.heap32[r10];
          r11 = r9 << numDefine2;
          r12 = (r10 + r11) | 0;
          r12 = r12 >> numDefine2;
          r11 = (r2 + r11) | 0;
          r12 = heapClassInst.heap32[r12];
          r9 = (r9 + 1) | 0;
          r11 = r11 >> numDefine2;
          heapClassInst.heap32[r11] = r12;
          if (!(r3 !== r9)) {
            break repeat12;
          }
        }
        r8 = (r0 + numDefine196) | 0;
      }
      if (r10 !== 0) {
        r9 = heapClassInst.heapU8[r0 + numDefine200];
        if (r9 !== 0) {
          r3 = gNumAlignedFree;
          r3 = r3 >> numDefine2;
          r9 = heapClassInst.heap32[r3];
          r9 = (r9 + 1) | 0;
          r10 = r10 >> numDefine2;
          heapClassInst.heap32[r3] = r9;
          r3 = heapClassInst.heap32[r10 + -1];
          heapClassInst.heap32[g0] = r3;
          free(i7);
          r3 = heapClassInst.heap32[r1 + numDefine47];
        }
        r9 = r8 >> numDefine2;
        heapClassInst.heap32[r9] = 0;
      }
      r8 = r8 >> numDefine2;
      heapClassInst.heap8[r0 + numDefine200] = r6;
      heapClassInst.heap32[r8] = r2;
      heapClassInst.heap32[r1 + numDefine48] = r7;
    }
  }
  r0 = r3 << numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine49];
  r0 = (r2 + r0) | 0;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = r4;
  r0 = heapClassInst.heap32[r1 + numDefine47];
  r0 = (r0 + 1) | 0;
  heapClassInst.heap32[r1 + numDefine47] = r0;
  if (!(r5 === 0)) {
    r0 = r4 >> numDefine2;
    r1 = heapClassInst.heap32[r0 + numDefine5];
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heap32[g0 + 1] = r4;
    zn11btRigidBody16addConstraintRefEP17btTypedConstraint(i7);
    r0 = heapClassInst.heap32[r0 + numDefine6];
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r4;
    zn11btRigidBody16addConstraintRefEP17btTypedConstraint(i7);
  }
  return;
}

function zn23btDiscreteDynamicsWorld21updateActivationStateEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr1097;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r1 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r1 < 1)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    r1 = gDisableDeactivation;
    r1 = heapClassInst.heapU8[r1];
    r2 = 0;
    repeat3: while (true) {
      r3 = heapClassInst.heap32[r0 + numDefine54];
      r4 = r2 << numDefine2;
      r3 = (r3 + r4) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      repeat5: do {
        if (!(r3 === 0)) {
          r4 = r3 >> numDefine2;
          r5 = heapClassInst.heap32[r4 + numDefine54];
          if (!(r5 === numDefine4)) {
            repeat8: do {
              if (r5 !== numDefine2) {
                f1 = heapClassInst.heapFloat[r4 + numDefine76];
                f2 = heapClassInst.heapFloat[r4 + numDefine77];
                f3 = heapClassInst.heapFloat[r4 + numDefine78];
                f1 = f1 * f1;
                f2 = f2 * f2;
                f4 = heapClassInst.heapFloat[r4 + numDefine116];
                f1 = f1 + f2;
                f2 = f3 * f3;
                f1 = f1 + f2;
                f2 = f4 * f4;
                if (f1 >= f2) {
                  label = numDefine8;
                } else {
                  f1 = heapClassInst.heapFloat[r4 + numDefine80];
                  f2 = heapClassInst.heapFloat[r4 + numDefine81];
                  f3 = heapClassInst.heapFloat[r4 + numDefine82];
                  f1 = f1 * f1;
                  f2 = f2 * f2;
                  f4 = heapClassInst.heapFloat[r4 + numDefine117];
                  f1 = f1 + f2;
                  f2 = f3 * f3;
                  f1 = f1 + f2;
                  f2 = f4 * f4;
                  if (f1 >= f2) {
                    label = numDefine8;
                  } else {
                    f1 = heapClassInst.heapFloat[r4 + numDefine55];
                    f1 = f1 + f0;
                    heapClassInst.heapFloat[r4 + numDefine55] = f1;
                    label = numDefine10;
                  }
                }
                if (label === numDefine8) {
                  r6 = (r5 + numDefineNeg4) | 0;
                  heapClassInst.heap32[r4 + numDefine55] = 0;
                  if (!(uint(r6) < uint(numDefine2))) {
                    r5 = 0;
                    heapClassInst.heap32[r4 + numDefine54] = 0;
                    break repeat8;
                  }
                }
                if (r5 === numDefine4) {
                  break repeat5;
                }
              }
            } while (false);
            r6 = r1 & numDefine255;
            repeat18: do {
              if (!(r6 !== 0)) {
                r6 = (r5 + numDefineNeg2) | 0;
                if (!(uint(r6) < uint(numDefine2))) {
                  f1 = heapClassInst.heapFloat[r4 + numDefine55];
                  f2 = numDefine2;
                  if (f1 <= f2) {
                    break repeat18;
                  }
                }
                r3 = heapClassInst.heapU8[r3 + numDefine204];
                r3 = r3 & numDefine3;
                if (r3 === 0) {
                  if (r5 === numDefine2) {
                    heapClassInst.heap32[r4 + numDefine76] = 0;
                    heapClassInst.heap32[r4 + numDefine77] = 0;
                    heapClassInst.heap32[r4 + numDefine78] = 0;
                    heapClassInst.heap32[r4 + numDefine79] = 0;
                    heapClassInst.heap32[r4 + numDefine80] = 0;
                    heapClassInst.heap32[r4 + numDefine81] = 0;
                    heapClassInst.heap32[r4 + numDefine82] = 0;
                    heapClassInst.heap32[r4 + numDefine83] = 0;
                    break repeat5;
                  } else {
                    if (r5 !== 1) {
                      break repeat5;
                    } else {
                      heapClassInst.heap32[r4 + numDefine54] = numDefine3;
                      break repeat5;
                    }
                  }
                } else {
                  r5 = (r5 + numDefineNeg4) | 0;
                  if (uint(r5) < uint(numDefine2)) {
                    break repeat5;
                  } else {
                    heapClassInst.heap32[r4 + numDefine54] = numDefine2;
                    break repeat5;
                  }
                }
              }
            } while (false);
            r3 = (r5 + numDefineNeg4) | 0;
            if (!(uint(r3) < uint(numDefine2))) {
              heapClassInst.heap32[r4 + numDefine54] = 1;
            }
          }
        }
      } while (false);
      r2 = (r2 + 1) | 0;
      r3 = heapClassInst.heap32[r0 + numDefine52];
      if (r3 > r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat35: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat35;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld28internalSingleStepSimulationEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg32;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr1198;
  r1 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r2 = heapClassInst.heap32[r0 + numDefine24];
  f0 = heapClassInst.heapFloat[fp + 1];
  if (!(r2 === 0)) {
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heapFloat[g0 + 1] = f0;
    functionTable[r2 >> numDefine2](i7);
  }
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine33];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heapFloat[g0 + 1] = f0;
  functionTable[r2 >> numDefine2](i7);
  heapClassInst.heapFloat[r0 + numDefine7] = f0;
  heapClassInst.heap32[r0 + numDefine8] = 0;
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  heapClassInst.heap32[g0] = r1;
  functionTable[r2 >> numDefine2](i7);
  heapClassInst.heap32[r0 + numDefine12] = commonVariable.rg0;
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine10];
  heapClassInst.heap32[g0] = r1;
  functionTable[r2 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine35];
  heapClassInst.heap32[g0] = r1;
  functionTable[r2 >> numDefine2](i7);
  heapClassInst.heapFloat[r0 + numDefine29] = f0;
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine36];
  r3 = (r1 + numDefine104) | 0;
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r3;
  functionTable[r2 >> numDefine2](i7);
  r2 = heapClassInst.heap32[r0];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine34];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heapFloat[g0 + 1] = f0;
  functionTable[r2 >> numDefine2](i7);
  r2 = twoEStr289;
  heapClassInst.heap32[g0] = r2;
  zn15CProfileManager13StartProfileEPKc(i7);
  r2 = heapClassInst.heap32[r0 + numDefine63];
  if (!(r2 < 1)) {
    r2 = 0;
    repeat6: while (true) {
      r3 = heapClassInst.heap32[r0 + numDefine65];
      r4 = r2 << numDefine2;
      r3 = (r3 + r4) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r4 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r4];
      r4 = r4 >> numDefine2;
      r4 = heapClassInst.heap32[r4 + numDefine2];
      heapClassInst.heap32[g0] = r3;
      heapClassInst.heap32[g0 + 1] = r1;
      heapClassInst.heapFloat[g0 + numDefine2] = f0;
      r2 = (r2 + 1) | 0;
      functionTable[r4 >> numDefine2](i7);
      r3 = heapClassInst.heap32[r0 + numDefine63];
      if (r3 > r2) {
        continue repeat6;
      } else {
        break repeat6;
      }
    }
  }
  r2 = zn15CProfileManager11CurrentNodeE;
  r2 = r2 >> numDefine2;
  r3 = heapClassInst.heap32[r2];
  r4 = r3 >> numDefine2;
  r5 = heapClassInst.heap32[r4 + numDefine4];
  r5 = (r5 + -1) | 0;
  heapClassInst.heap32[r4 + numDefine4] = r5;
  repeat9: do {
    if (!(r5 !== 0)) {
      r5 = heapClassInst.heap32[r4 + 1];
      if (r5 !== 0) {
        r3 = sp + numDefineNeg16;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = 0;
        r5 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r5 = r5 >> numDefine2;
        r5 = heapClassInst.heap32[r5];
        r5 = r5 >> numDefine2;
        r3 = r3 >> numDefine2;
        r6 = heapClassInst.heap32[fp + numDefineNeg4];
        r7 = heapClassInst.heap32[r5];
        r6 = (r6 - r7) | 0;
        r3 = heapClassInst.heap32[r3 + 1];
        r5 = heapClassInst.heap32[r5 + 1];
        r3 = (r3 - r5) | 0;
        r5 = (r6 * numDefineN6) | 0;
        r3 = (r3 + r5) | 0;
        r5 = heapClassInst.heap32[r4 + numDefine3];
        r3 = (r3 - r5) | 0;
        f1 = uint(r3);
        f2 = numDefine1000;
        f3 = heapClassInst.heapFloat[r4 + numDefine2];
        f1 = f1 / f2;
        f1 = f3 + f1;
        heapClassInst.heapFloat[r4 + numDefine2] = f1;
        r3 = heapClassInst.heap32[r4 + numDefine4];
        if (r3 !== 0) {
          break repeat9;
        } else {
          r3 = heapClassInst.heap32[r2];
        }
      }
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine5];
      heapClassInst.heap32[r2] = r3;
    }
  } while (false);
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heapFloat[g0 + 1] = f0;
  zn23btDiscreteDynamicsWorld21updateActivationStateEf(i7);
  r0 = heapClassInst.heap32[r0 + numDefine23];
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r1;
    heapClassInst.heapFloat[g0 + 1] = f0;
    functionTable[r0 >> numDefine2](i7);
  }
  r0 = heapClassInst.heap32[r2];
  r1 = r0 >> numDefine2;
  r3 = heapClassInst.heap32[r1 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r1 + numDefine4] = r3;
  repeat19: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r1 + 1];
      if (r3 !== 0) {
        r0 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r0 = r0 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r0 = heapClassInst.heap32[r0 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r0 = (r0 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r0 = (r0 + r3) | 0;
        r3 = heapClassInst.heap32[r1 + numDefine3];
        r0 = (r0 - r3) | 0;
        f0 = uint(r0);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r1 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r1 + numDefine2] = f0;
        r0 = heapClassInst.heap32[r1 + numDefine4];
        if (r0 !== 0) {
          break repeat19;
        } else {
          r0 = heapClassInst.heap32[r2];
        }
      }
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine5];
      heapClassInst.heap32[r2] = r0;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBodyss(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine51];
  r3 = heapClassInst.heap32[fp];
  r4 = r2 & numDefine3;
  if (!(r4 !== 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine496];
    r4 = r4 & 1;
    if (!(r4 !== 0)) {
      f0 = heapClassInst.heapFloat[r1 + numDefine84];
      f1 = 0;
      if (!(f0 === f1)) {
        r4 = r3 >> numDefine2;
        f1 = 1;
        f0 = f1 / f0;
        f1 = heapClassInst.heapFloat[r4 + numDefine58];
        f2 = heapClassInst.heapFloat[r4 + numDefine57];
        f3 = heapClassInst.heapFloat[r4 + numDefine56];
        f3 = f3 * f0;
        f2 = f2 * f0;
        heapClassInst.heapFloat[r1 + numDefine89] = f3;
        f0 = f1 * f0;
        heapClassInst.heapFloat[r1 + numDefine90] = f2;
        heapClassInst.heapFloat[r1 + numDefine91] = f0;
        heapClassInst.heap32[r1 + numDefine92] = 0;
      }
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r4 + numDefine56];
      heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r4 + numDefine57];
      heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r4 + numDefine58];
      heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r4 + numDefine59];
    }
  }
  r4 = heapClassInst.heap32[r1 + numDefine48];
  if (!(r4 === 0)) {
    r4 = heapClassInst.heap32[fp + numDefine2];
    r5 = heapClassInst.heap32[fp + numDefine3];
    r2 = r2 & 1;
    repeat10: do {
      if (r2 !== 0) {
        r2 = heapClassInst.heap32[r1 + numDefine54];
        r2 = (r2 + numDefineNeg4) | 0;
        if (uint(r2) < uint(numDefine2)) {
          break repeat10;
        } else {
          heapClassInst.heap32[r1 + numDefine54] = numDefine2;
        }
      } else {
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine53];
        r6 = heapClassInst.heap32[r1 + numDefine52];
        if (r2 === r6) {
          r7 = 1;
          r8 = r6 << 1;
          r8 = r6 === 0 ? r7 : r8;
          if (!(r2 >= r8)) {
            if (r8 !== 0) {
              r2 = gNumAlignedAllocs;
              r2 = r2 >> numDefine2;
              r9 = heapClassInst.heap32[r2];
              r10 = r8 << numDefine2;
              r9 = (r9 + 1) | 0;
              r10 = r10 | numDefine3;
              heapClassInst.heap32[r2] = r9;
              r2 = (r10 + numDefine16) | 0;
              heapClassInst.heap32[g0] = r2;
              mallocNew(i7);
              r2 = commonVariable.rg0;
              if (r2 !== 0) {
                r9 = 0;
                r10 = (r2 + numDefine4) | 0;
                r9 = (r9 - r10) | 0;
                r9 = r9 & numDefine15;
                r9 = (r2 + r9) | 0;
                r10 = (r9 + numDefine4) | 0;
                r9 = r9 >> numDefine2;
                heapClassInst.heap32[r9] = r2;
                r2 = r10;
              }
            } else {
              r2 = 0;
            }
            r9 = (r3 + numDefine216) | 0;
            if (r6 < 1) {
              r10 = r9 >> numDefine2;
              r11 = heapClassInst.heap32[r10];
            } else {
              r10 = 0;
              repeat25: while (true) {
                r11 = r9 >> numDefine2;
                r11 = heapClassInst.heap32[r11];
                r12 = r10 << numDefine2;
                r13 = (r11 + r12) | 0;
                r13 = r13 >> numDefine2;
                r12 = (r2 + r12) | 0;
                r13 = heapClassInst.heap32[r13];
                r10 = (r10 + 1) | 0;
                r12 = r12 >> numDefine2;
                heapClassInst.heap32[r12] = r13;
                if (!(r6 !== r10)) {
                  break repeat25;
                }
              }
              r9 = (r3 + numDefine216) | 0;
            }
            if (r11 !== 0) {
              r10 = heapClassInst.heapU8[r3 + numDefine220];
              if (r10 !== 0) {
                r6 = gNumAlignedFree;
                r6 = r6 >> numDefine2;
                r10 = heapClassInst.heap32[r6];
                r10 = (r10 + 1) | 0;
                r11 = r11 >> numDefine2;
                heapClassInst.heap32[r6] = r10;
                r6 = heapClassInst.heap32[r11 + -1];
                heapClassInst.heap32[g0] = r6;
                free(i7);
                r6 = heapClassInst.heap32[r1 + numDefine52];
              }
              r10 = r9 >> numDefine2;
              heapClassInst.heap32[r10] = 0;
            }
            r9 = r9 >> numDefine2;
            heapClassInst.heap8[r3 + numDefine220] = r7;
            heapClassInst.heap32[r9] = r2;
            heapClassInst.heap32[r1 + numDefine53] = r8;
          }
        }
        r2 = r6 << numDefine2;
        r6 = heapClassInst.heap32[r1 + numDefine54];
        r2 = (r6 + r2) | 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r2] = r0;
        r2 = heapClassInst.heap32[r1 + numDefine52];
        r2 = (r2 + 1) | 0;
        heapClassInst.heap32[r1 + numDefine52] = r2;
      }
    } while (false);
    r1 = r3 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine8];
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r5;
    functionTable[r1 >> numDefine2](i7);
  }
  return;
}

function zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBody(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1 + numDefine51];
  r3 = heapClassInst.heap32[fp];
  r4 = r2 & numDefine3;
  if (!(r4 !== 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine496];
    r4 = r4 & 1;
    if (!(r4 !== 0)) {
      f0 = heapClassInst.heapFloat[r1 + numDefine84];
      f1 = 0;
      if (!(f0 === f1)) {
        r4 = r3 >> numDefine2;
        f1 = 1;
        f0 = f1 / f0;
        f1 = heapClassInst.heapFloat[r4 + numDefine58];
        f2 = heapClassInst.heapFloat[r4 + numDefine57];
        f3 = heapClassInst.heapFloat[r4 + numDefine56];
        f3 = f3 * f0;
        f2 = f2 * f0;
        heapClassInst.heapFloat[r1 + numDefine89] = f3;
        f0 = f1 * f0;
        heapClassInst.heapFloat[r1 + numDefine90] = f2;
        heapClassInst.heapFloat[r1 + numDefine91] = f0;
        heapClassInst.heap32[r1 + numDefine92] = 0;
      }
      r4 = r3 >> numDefine2;
      heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r4 + numDefine56];
      heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r4 + numDefine57];
      heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r4 + numDefine58];
      heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r4 + numDefine59];
    }
  }
  r4 = heapClassInst.heap32[r1 + numDefine48];
  if (!(r4 === 0)) {
    r4 = r2 & 1;
    repeat10: do {
      if (r4 !== 0) {
        r4 = heapClassInst.heap32[r1 + numDefine54];
        r4 = (r4 + numDefineNeg4) | 0;
        if (uint(r4) > uint(1)) {
          heapClassInst.heap32[r1 + numDefine54] = numDefine2;
        } else {
          break repeat10;
        }
      } else {
        r2 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r2 + numDefine53];
        r5 = heapClassInst.heap32[r2 + numDefine52];
        if (r4 === r5) {
          r6 = 1;
          r7 = r5 << 1;
          r7 = r5 === 0 ? r6 : r7;
          if (!(r4 >= r7)) {
            if (r7 !== 0) {
              r4 = gNumAlignedAllocs;
              r4 = r4 >> numDefine2;
              r8 = heapClassInst.heap32[r4];
              r9 = r7 << numDefine2;
              r8 = (r8 + 1) | 0;
              r9 = r9 | numDefine3;
              heapClassInst.heap32[r4] = r8;
              r4 = (r9 + numDefine16) | 0;
              heapClassInst.heap32[g0] = r4;
              mallocNew(i7);
              r4 = commonVariable.rg0;
              if (r4 !== 0) {
                r8 = 0;
                r9 = (r4 + numDefine4) | 0;
                r8 = (r8 - r9) | 0;
                r8 = r8 & numDefine15;
                r8 = (r4 + r8) | 0;
                r9 = (r8 + numDefine4) | 0;
                r8 = r8 >> numDefine2;
                heapClassInst.heap32[r8] = r4;
                r4 = r9;
              }
            } else {
              r4 = 0;
            }
            r8 = (r3 + numDefine216) | 0;
            if (r5 < 1) {
              r9 = r8 >> numDefine2;
              r10 = heapClassInst.heap32[r9];
            } else {
              r9 = 0;
              repeat25: while (true) {
                r10 = r8 >> numDefine2;
                r10 = heapClassInst.heap32[r10];
                r11 = r9 << numDefine2;
                r12 = (r10 + r11) | 0;
                r12 = r12 >> numDefine2;
                r11 = (r4 + r11) | 0;
                r12 = heapClassInst.heap32[r12];
                r9 = (r9 + 1) | 0;
                r11 = r11 >> numDefine2;
                heapClassInst.heap32[r11] = r12;
                if (!(r5 !== r9)) {
                  break repeat25;
                }
              }
              r8 = (r3 + numDefine216) | 0;
            }
            if (r10 !== 0) {
              r9 = heapClassInst.heapU8[r3 + numDefine220];
              if (r9 !== 0) {
                r5 = gNumAlignedFree;
                r5 = r5 >> numDefine2;
                r9 = heapClassInst.heap32[r5];
                r9 = (r9 + 1) | 0;
                r10 = r10 >> numDefine2;
                heapClassInst.heap32[r5] = r9;
                r5 = heapClassInst.heap32[r10 + -1];
                heapClassInst.heap32[g0] = r5;
                free(i7);
                r5 = heapClassInst.heap32[r2 + numDefine52];
              }
              r9 = r8 >> numDefine2;
              heapClassInst.heap32[r9] = 0;
            }
            r8 = r8 >> numDefine2;
            heapClassInst.heap8[r3 + numDefine220] = r6;
            heapClassInst.heap32[r8] = r4;
            heapClassInst.heap32[r2 + numDefine53] = r7;
          }
        }
        r4 = r5 << numDefine2;
        r5 = heapClassInst.heap32[r2 + numDefine54];
        r4 = (r5 + r4) | 0;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r4] = r0;
        r4 = heapClassInst.heap32[r2 + numDefine52];
        r4 = (r4 + 1) | 0;
        heapClassInst.heap32[r2 + numDefine52] = r4;
        r2 = heapClassInst.heap32[r1 + numDefine51];
      }
    } while (false);
    r1 = r3 >> numDefine2;
    r1 = heapClassInst.heap32[r1];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine8];
    r4 = numDefine2;
    r5 = 1;
    r2 = r2 & numDefine3;
    r6 = numDefineNeg3;
    r7 = -1;
    r4 = r2 !== 0 ? r4 : r5;
    r2 = r2 !== 0 ? r6 : r7;
    heapClassInst.heap32[g0] = r3;
    heapClassInst.heap32[g0 + 1] = r0;
    heapClassInst.heap32[g0 + numDefine2] = r4;
    heapClassInst.heap32[g0 + numDefine3] = r2;
    functionTable[r1 >> numDefine2](i7);
  }
  return;
}

function zn23btDiscreteDynamicsWorld10setGravityERK9btVector3(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r0 + numDefine56] = heapClassInst.heap32[r1];
  heapClassInst.heap32[r0 + numDefine57] = heapClassInst.heap32[r1 + 1];
  heapClassInst.heap32[r0 + numDefine58] = heapClassInst.heap32[r1 + numDefine2];
  heapClassInst.heap32[r0 + numDefine59] = heapClassInst.heap32[r1 + numDefine3];
  r2 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r2 < 1)) {
    r2 = 0;
    repeat3: while (true) {
      r3 = heapClassInst.heap32[r0 + numDefine54];
      r4 = r2 << numDefine2;
      r3 = (r3 + r4) | 0;
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r4 = r3 >> numDefine2;
      r5 = heapClassInst.heap32[r4 + numDefine54];
      if (!(r5 === numDefine2)) {
        if (!(r5 === numDefine5)) {
          r3 = heapClassInst.heapU8[r3 + numDefine496];
          r3 = r3 & 1;
          if (!(r3 !== 0)) {
            f0 = heapClassInst.heapFloat[r4 + numDefine84];
            f1 = 0;
            if (!(f0 === f1)) {
              f1 = 1;
              f0 = f1 / f0;
              f1 = heapClassInst.heapFloat[r1 + numDefine2];
              f2 = heapClassInst.heapFloat[r1 + 1];
              f3 = heapClassInst.heapFloat[r1];
              f3 = f3 * f0;
              f2 = f2 * f0;
              heapClassInst.heapFloat[r4 + numDefine89] = f3;
              f0 = f1 * f0;
              heapClassInst.heapFloat[r4 + numDefine90] = f2;
              heapClassInst.heapFloat[r4 + numDefine91] = f0;
              heapClassInst.heap32[r4 + numDefine92] = 0;
            }
            heapClassInst.heap32[r4 + numDefine93] = heapClassInst.heap32[r1];
            heapClassInst.heap32[r4 + numDefine94] = heapClassInst.heap32[r1 + 1];
            heapClassInst.heap32[r4 + numDefine95] = heapClassInst.heap32[r1 + numDefine2];
            heapClassInst.heap32[r4 + numDefine96] = heapClassInst.heap32[r1 + numDefine3];
          }
        }
      }
      r2 = (r2 + 1) | 0;
      r3 = heapClassInst.heap32[r0 + numDefine52];
      if (r3 > r2) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn23btDiscreteDynamicsWorld15removeRigidBodyEP11btRigidBody(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[r1 + numDefine52];
  r4 = 0;
  repeat1: while (true) {
    if (r3 > r4) {
      r5 = heapClassInst.heap32[r1 + numDefine54];
      r6 = r4 << numDefine2;
      r5 = (r5 + r6) | 0;
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      if (r5 !== r2) {
        r4 = (r4 + 1) | 0;
        continue repeat1;
      } else {
        label = numDefine5;
        break repeat1;
      }
    } else {
      label = numDefine4;
      break repeat1;
    }
  }
  if (label === numDefine4) {
    r4 = r3;
  }
  if (!(r3 <= r4)) {
    r3 = (r3 + -1) | 0;
    r4 = r4 << numDefine2;
    r5 = heapClassInst.heap32[r1 + numDefine54];
    r3 = r3 << numDefine2;
    r4 = (r5 + r4) | 0;
    r5 = (r5 + r3) | 0;
    r4 = r4 >> numDefine2;
    r5 = r5 >> numDefine2;
    r6 = heapClassInst.heap32[r4];
    r5 = heapClassInst.heap32[r5];
    heapClassInst.heap32[r4] = r5;
    r4 = heapClassInst.heap32[r1 + numDefine54];
    r3 = (r4 + r3) | 0;
    r3 = r3 >> numDefine2;
    heapClassInst.heap32[r3] = r6;
    r3 = heapClassInst.heap32[r1 + numDefine52];
    r3 = (r3 + -1) | 0;
    heapClassInst.heap32[r1 + numDefine52] = r3;
  }
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r2;
  zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject(i7);
  return;
}

function zn23btDiscreteDynamicsWorld21removeCollisionObjectEP17btCollisionObject(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heap32[fp];
  r2 = heapClassInst.heapU8[r0 + numDefine232];
  r2 = r2 & numDefine2;
  if (!(r2 === 0)) {
    if (!(r0 === 0)) {
      r2 = r1 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2 + numDefine21];
      heapClassInst.heap32[g0] = r1;
      heapClassInst.heap32[g0 + 1] = r0;
      functionTable[r2 >> numDefine2](i7);
      return;
    }
  }
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r0;
  zn16btCollisionWorld21removeCollisionObjectEP17btCollisionObject(i7);
  return;
}

function zn23btDiscreteDynamicsWorld18addCollisionObjectEP17btCollisionObjectss(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  r3 = heapClassInst.heap32[fp + numDefine3];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  heapClassInst.heap32[g0 + numDefine3] = r3;
  zn16btCollisionWorld18addCollisionObjectEP17btCollisionObjectss(i7);
  return;
}

function zn23btDiscreteDynamicsWorld14stepSimulationEfif(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  zn15CProfileManager5ResetEv(i7);
  r0 = twoEStr1299;
  r1 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp];
  f0 = heapClassInst.heapFloat[fp + 1];
  zn15CProfileManager13StartProfileEPKc(i7);
  if (r1 === 0) {
    r1 = r0 >> numDefine2;
    f1 = 0;
    heapClassInst.heapFloat[r1 + numDefine60] = f0;
    if (f0 < f1) {
      f1 = -f0;
    } else {
      f1 = f0;
    }
    f2 = numDefineFloat1257;
    if (f1 >= f2) {
      r1 = 1;
      f1 = f0;
      r3 = r1;
    } else {
      r1 = 0;
      f1 = f0;
      r3 = r1;
    }
  } else {
    f1 = heapClassInst.heapFloat[fp + numDefine3];
    r2 = r0 >> numDefine2;
    f2 = heapClassInst.heapFloat[r2 + numDefine60];
    f0 = f2 + f0;
    heapClassInst.heapFloat[r2 + numDefine60] = f0;
    if (f0 >= f1) {
      f2 = f0 / f1;
      r3 = f2 | 0;
      f2 = r3;
      f2 = f2 * f1;
      f0 = f0 - f2;
      heapClassInst.heapFloat[r2 + numDefine60] = f0;
    } else {
      r3 = 0;
    }
  }
  r2 = r0 >> numDefine2;
  r4 = heapClassInst.heap32[r2];
  r4 = r4 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  if (!(r4 === 0)) {
    r4 = heapClassInst.heap32[r2];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine4];
    heapClassInst.heap32[g0] = r0;
    functionTable[r4 >> numDefine2](i7);
    r5 = commonVariable.rg0 >> numDefine2;
    r5 = heapClassInst.heap32[r5];
    r5 = r5 >> numDefine2;
    r5 = heapClassInst.heap32[r5 + numDefine12];
    heapClassInst.heap32[g0] = commonVariable.rg0;
    functionTable[r5 >> numDefine2](i7);
    r4 = commonVariable.rg0 >>> numDefine4;
    r5 = gDisableDeactivation;
    r4 = r4 & 1;
    heapClassInst.heap8[r5] = r4;
  }
  if (r3 === 0) {
    r1 = heapClassInst.heap32[r2];
    r1 = r1 >> numDefine2;
    r1 = heapClassInst.heap32[r1 + numDefine19];
    heapClassInst.heap32[g0] = r0;
    functionTable[r1 >> numDefine2](i7);
  } else {
    r4 = heapClassInst.heap32[r2];
    r4 = r4 >> numDefine2;
    r5 = r3 > r1 ? r1 : r3;
    r4 = heapClassInst.heap32[r4 + numDefine38];
    f0 = r5;
    f0 = f0 * f1;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heapFloat[g0 + 1] = f0;
    functionTable[r4 >> numDefine2](i7);
    r4 = heapClassInst.heap32[r2];
    r4 = r4 >> numDefine2;
    r4 = heapClassInst.heap32[r4 + numDefine40];
    heapClassInst.heap32[g0] = r0;
    functionTable[r4 >> numDefine2](i7);
    if (!(r5 < 1)) {
      r4 = r3 ^ -1;
      r1 = r1 ^ -1;
      r1 = r4 > r1 ? r4 : r1;
      r1 = r1 ^ -1;
      repeat22: while (true) {
        r4 = heapClassInst.heap32[r2];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine37];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heapFloat[g0 + 1] = f1;
        functionTable[r4 >> numDefine2](i7);
        r4 = heapClassInst.heap32[r2];
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4 + numDefine19];
        r1 = (r1 + -1) | 0;
        heapClassInst.heap32[g0] = r0;
        functionTable[r4 >> numDefine2](i7);
        if (r1 === 0) {
          break repeat22;
        } else {
          continue repeat22;
        }
      }
    }
  }
  r1 = heapClassInst.heap32[r2];
  r1 = r1 >> numDefine2;
  r1 = heapClassInst.heap32[r1 + numDefine28];
  heapClassInst.heap32[g0] = r0;
  r0 = zn15CProfileManager12FrameCounterE;
  functionTable[r1 >> numDefine2](i7);
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = zn15CProfileManager11CurrentNodeE;
  r1 = (r1 + 1) | 0;
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r0] = r1;
  r0 = heapClassInst.heap32[r2];
  r1 = r0 >> numDefine2;
  r4 = heapClassInst.heap32[r1 + numDefine4];
  r4 = (r4 + -1) | 0;
  heapClassInst.heap32[r1 + numDefine4] = r4;
  repeat25: do {
    if (!(r4 !== 0)) {
      r4 = heapClassInst.heap32[r1 + 1];
      if (r4 !== 0) {
        r0 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = 0;
        r4 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r4 = r4 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r4 = r4 >> numDefine2;
        r0 = r0 >> numDefine2;
        r5 = heapClassInst.heap32[fp + numDefineNeg2];
        r6 = heapClassInst.heap32[r4];
        r5 = (r5 - r6) | 0;
        r0 = heapClassInst.heap32[r0 + 1];
        r4 = heapClassInst.heap32[r4 + 1];
        r0 = (r0 - r4) | 0;
        r4 = (r5 * numDefineN6) | 0;
        r0 = (r0 + r4) | 0;
        r4 = heapClassInst.heap32[r1 + numDefine3];
        r0 = (r0 - r4) | 0;
        f0 = uint(r0);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r1 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r1 + numDefine2] = f0;
        r0 = heapClassInst.heap32[r1 + numDefine4];
        if (r0 !== 0) {
          break repeat25;
        } else {
          r0 = heapClassInst.heap32[r2];
        }
      }
      r0 = r0 >> numDefine2;
      r0 = heapClassInst.heap32[r0 + numDefine5];
      heapClassInst.heap32[r2] = r0;
    }
  } while (false);
  commonVariable.rg0 = r3;
  return;
}

function zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg96;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  if (r0 !== 0) {
    r1 = r0 >> numDefine2;
    r2 = heapClassInst.heap32[r1 + numDefine118];
    if (!(r2 === 0)) {
      r2 = heapClassInst.heapU8[r0 + numDefine204];
      r2 = r2 & numDefine3;
      if (r2 === 0) {
        r2 = heapClassInst.heap32[fp];
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine60];
        f1 = heapClassInst.heapFloat[r1 + numDefine60];
        f2 = heapClassInst.heapFloat[r1 + numDefine33];
        f3 = heapClassInst.heapFloat[r1 + numDefine34];
        f4 = heapClassInst.heapFloat[r1 + numDefine35];
        r2 = sp + numDefineNeg64;
        r3 = (r0 + numDefine68) | 0;
        r0 = (r0 + numDefine148) | 0;
        f0 = f0 * f1;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heapFloat[g0 + 1] = f2;
        heapClassInst.heapFloat[g0 + numDefine2] = f3;
        heapClassInst.heapFloat[g0 + numDefine3] = f4;
        heapClassInst.heap32[g0 + numDefine4] = r0;
        heapClassInst.heapFloat[g0 + numDefine5] = f0;
        heapClassInst.heap32[g0 + numDefine6] = r2;
        zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
        r0 = heapClassInst.heap32[r1 + numDefine118];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable[r1 >> numDefine2](i7);
        return;
      }
    }
    return;
  } else {
    r0 = twoEStr13100;
    r1 = twoEStr1461;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r1;
    heapClassInst.heap32[g0 + numDefine2] = numDefine184;
    assertNew(i7);
  }
}

function zn23btDiscreteDynamicsWorld23synchronizeMotionStatesEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr1562;
  heapClassInst.heap32[g0] = r0;
  r0 = heapClassInst.heap32[fp];
  zn15CProfileManager13StartProfileEPKc(i7);
  r1 = heapClassInst.heapU8[r0 + numDefine246];
  repeat1: do {
    if (r1 !== 0) {
      r1 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r1 + numDefine2];
      if (!(r2 < 1)) {
        r2 = 0;
        repeat4: while (true) {
          r3 = heapClassInst.heap32[r1 + numDefine4];
          r4 = r2 << numDefine2;
          r3 = (r3 + r4) | 0;
          r3 = r3 >> numDefine2;
          r3 = heapClassInst.heap32[r3];
          r4 = heapClassInst.heapU8[r3 + numDefine232];
          r4 = r4 & numDefine2;
          if (!(r4 === 0)) {
            if (!(r3 === 0)) {
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r3;
              zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(i7);
            }
          }
          r2 = (r2 + 1) | 0;
          r3 = heapClassInst.heap32[r1 + numDefine2];
          if (r3 > r2) {
            continue repeat4;
          } else {
            break repeat1;
          }
        }
      }
    } else {
      r1 = r0 >> numDefine2;
      r2 = heapClassInst.heap32[r1 + numDefine52];
      if (r2 > 0) {
        r2 = 0;
        repeat12: while (true) {
          r3 = heapClassInst.heap32[r1 + numDefine54];
          r4 = r2 << numDefine2;
          r3 = (r3 + r4) | 0;
          r3 = r3 >> numDefine2;
          r3 = heapClassInst.heap32[r3];
          r4 = r3 >> numDefine2;
          r4 = heapClassInst.heap32[r4 + numDefine54];
          if (!(r4 === numDefine2)) {
            if (!(r4 === numDefine5)) {
              heapClassInst.heap32[g0] = r0;
              heapClassInst.heap32[g0 + 1] = r3;
              zn23btDiscreteDynamicsWorld28synchronizeSingleMotionStateEP11btRigidBody(i7);
            }
          }
          r2 = (r2 + 1) | 0;
          r3 = heapClassInst.heap32[r1 + numDefine52];
          if (r3 > r2) {
            continue repeat12;
          } else {
            break repeat1;
          }
        }
      }
    }
  } while (false);
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat19: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat19;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld12applyGravityEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine52];
  if (!(r1 < 1)) {
    r1 = 0;
    repeat3: while (true) {
      r2 = heapClassInst.heap32[r0 + numDefine54];
      r3 = r1 << numDefine2;
      r2 = (r2 + r3) | 0;
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r3 = r2 >> numDefine2;
      r4 = heapClassInst.heap32[r3 + numDefine54];
      if (!(r4 === numDefine2)) {
        if (!(r4 === numDefine5)) {
          r2 = heapClassInst.heapU8[r2 + numDefine204];
          r2 = r2 & numDefine3;
          if (!(r2 !== 0)) {
            f0 = heapClassInst.heapFloat[r3 + numDefine89];
            f1 = heapClassInst.heapFloat[r3 + numDefine85];
            f0 = f0 * f1;
            f1 = heapClassInst.heapFloat[r3 + numDefine101];
            f2 = heapClassInst.heapFloat[r3 + numDefine91];
            f3 = heapClassInst.heapFloat[r3 + numDefine87];
            f4 = heapClassInst.heapFloat[r3 + numDefine90];
            f5 = heapClassInst.heapFloat[r3 + numDefine86];
            f0 = f1 + f0;
            heapClassInst.heapFloat[r3 + numDefine101] = f0;
            f0 = f4 * f5;
            f1 = heapClassInst.heapFloat[r3 + numDefine102];
            f0 = f1 + f0;
            heapClassInst.heapFloat[r3 + numDefine102] = f0;
            f0 = f2 * f3;
            f1 = heapClassInst.heapFloat[r3 + numDefine103];
            f0 = f1 + f0;
            heapClassInst.heapFloat[r3 + numDefine103] = f0;
          }
        }
      }
      r1 = (r1 + 1) | 0;
      r2 = heapClassInst.heap32[r0 + numDefine52];
      if (r2 > r1) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn23btDiscreteDynamicsWorld14debugDrawWorldEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let f12: number = 0.0;
  let f13: number = 0.0;
  let f14: number = 0.0;
  let f15: number = 0.0;
  let f16: number = 0.0;
  let f17: number = 0.0;
  let f18: number = 0.0;
  let f19: number = 0.0;
  let f20: number = 0.0;
  let f21: number = 0.0;
  let f22: number = 0.0;
  let f23: number = 0.0;
  let f24: number = 0.0;
  let f25: number = 0.0;
  let f26: number = 0.0;
  let f27: number = 0.0;
  let f28: number = 0.0;
  let f29: number = 0.0;
  let f30: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg824;
  let g0 = i7 >> numDefine2;
  r0 = twoEStr16101;
  heapClassInst.heap32[g0] = r0;
  zn15CProfileManager13StartProfileEPKc(i7);
  r0 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  zn16btCollisionWorld14debugDrawWorldEv(i7);
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  if (!(r2 === 0)) {
    r2 = heapClassInst.heap32[r1];
    r2 = r2 >> numDefine2;
    r2 = heapClassInst.heap32[r2 + numDefine4];
    heapClassInst.heap32[g0] = r0;
    functionTable[r2 >> numDefine2](i7);
    r3 = commonVariable.rg0 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3 + numDefine12];
    heapClassInst.heap32[g0] = commonVariable.rg0;
    functionTable[r3 >> numDefine2](i7);
    r2 = commonVariable.rg0 & numDefine6144;
    if (!(r2 === 0)) {
      r2 = heapClassInst.heap32[r1];
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2 + numDefine24];
      heapClassInst.heap32[g0] = r0;
      functionTable[r2 >> numDefine2](i7);
      r2 = commonVariable.rg0;
      r3 = (r2 + -1) | 0;
      if (!(r3 < 0)) {
        r3 = sp + numDefineNeg296;
        r4 = sp + numDefineNeg392;
        r5 = (r3 + numDefine48) | 0;
        r6 = (r4 + numDefine48) | 0;
        r2 = (r2 + -1) | 0;
        repeat5: while (true) {
          r7 = r2;
          r2 = heapClassInst.heap32[r1];
          r2 = r2 >> numDefine2;
          r2 = heapClassInst.heap32[r2 + numDefine25];
          heapClassInst.heap32[g0] = r0;
          heapClassInst.heap32[g0 + 1] = r7;
          functionTable[r2 >> numDefine2](i7);
          r2 = commonVariable.rg0;
          r8 = heapClassInst.heap32[r1];
          r8 = r8 >> numDefine2;
          r8 = heapClassInst.heap32[r8 + numDefine4];
          heapClassInst.heap32[g0] = r0;
          functionTable[r8 >> numDefine2](i7);
          r9 = commonVariable.rg0 >> numDefine2;
          r9 = heapClassInst.heap32[r9];
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefine12];
          heapClassInst.heap32[g0] = commonVariable.rg0;
          functionTable[r9 >> numDefine2](i7);
          r8 = commonVariable.rg0;
          r9 = heapClassInst.heap32[r1];
          r9 = r9 >> numDefine2;
          r9 = heapClassInst.heap32[r9 + numDefine4];
          heapClassInst.heap32[g0] = r0;
          functionTable[r9 >> numDefine2](i7);
          r10 = commonVariable.rg0 >> numDefine2;
          r10 = heapClassInst.heap32[r10];
          r10 = r10 >> numDefine2;
          r10 = heapClassInst.heap32[r10 + numDefine12];
          heapClassInst.heap32[g0] = commonVariable.rg0;
          functionTable[r10 >> numDefine2](i7);
          r9 = commonVariable.rg0;
          r10 = r2 >> numDefine2;
          f0 = heapClassInst.heapFloat[r10 + numDefine8];
          heapClassInst.heapFloat[fp + numDefineNeg191] = f0;
          f1 = 0;
          heapClassInst.heapFloat[fp + numDefineNeg192] = f1;
          repeat7: do {
            if (!(f0 <= f1)) {
              r8 = r8 >>> numDefine11;
              r9 = r9 >>> numDefine12;
              r8 = r8 & 1;
              r9 = r9 & 1;
              r10 = r2 >> numDefine2;
              r11 = heapClassInst.heap32[r10 + 1];
              if (r11 > numDefine4) {
                if (r11 === numDefine5) {
                  r11 = heapClassInst.heap32[r10 + numDefine5];
                  r11 = r11 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r11 + 1];
                  f1 = heapClassInst.heapFloat[r10 + numDefine72];
                  f2 = heapClassInst.heapFloat[r11 + numDefine2];
                  f3 = heapClassInst.heapFloat[r10 + numDefine76];
                  f4 = heapClassInst.heapFloat[r10 + numDefine73];
                  f5 = heapClassInst.heapFloat[r10 + numDefine77];
                  f6 = f1 * f0;
                  f7 = f3 * f2;
                  f8 = heapClassInst.heapFloat[r11 + numDefine3];
                  f9 = heapClassInst.heapFloat[r10 + numDefine80];
                  f10 = heapClassInst.heapFloat[r11 + numDefine9];
                  f11 = heapClassInst.heapFloat[r10 + numDefine84];
                  f12 = heapClassInst.heapFloat[r11 + numDefine5];
                  f13 = heapClassInst.heapFloat[r10 + numDefine74];
                  f14 = heapClassInst.heapFloat[r11 + numDefine10];
                  f15 = heapClassInst.heapFloat[r10 + numDefine85];
                  f16 = heapClassInst.heapFloat[r11 + numDefine6];
                  f17 = heapClassInst.heapFloat[r10 + numDefine78];
                  f18 = heapClassInst.heapFloat[r11 + numDefine11];
                  f19 = heapClassInst.heapFloat[r10 + numDefine86];
                  f20 = heapClassInst.heapFloat[r11 + numDefine7];
                  f21 = heapClassInst.heapFloat[r10 + numDefine82];
                  f22 = heapClassInst.heapFloat[r10 + numDefine81];
                  f23 = f4 * f0;
                  f24 = f5 * f2;
                  f6 = f6 + f7;
                  f7 = f9 * f8;
                  f25 = heapClassInst.heapFloat[r11 + numDefine15];
                  f26 = heapClassInst.heapFloat[r11 + numDefine14];
                  f27 = heapClassInst.heapFloat[r11 + numDefine13];
                  f28 = f13 * f0;
                  f29 = f17 * f2;
                  f23 = f23 + f24;
                  f24 = f22 * f8;
                  f6 = f6 + f7;
                  r11 = r4 >> numDefine2;
                  f7 = f28 + f29;
                  f28 = f21 * f8;
                  f23 = f23 + f24;
                  heapClassInst.heapFloat[fp + numDefineNeg98] = f6;
                  f6 = f1 * f12;
                  f24 = f3 * f16;
                  f7 = f7 + f28;
                  heapClassInst.heapFloat[r11 + 1] = f23;
                  heapClassInst.heapFloat[r11 + numDefine2] = f7;
                  f7 = f4 * f12;
                  f23 = f5 * f16;
                  f6 = f6 + f24;
                  f24 = f9 * f20;
                  f28 = f13 * f12;
                  f29 = f17 * f16;
                  f7 = f7 + f23;
                  f23 = f22 * f20;
                  f6 = f6 + f24;
                  heapClassInst.heap32[r11 + numDefine3] = 0;
                  f24 = f28 + f29;
                  f28 = f21 * f20;
                  f7 = f7 + f23;
                  heapClassInst.heapFloat[r11 + numDefine4] = f6;
                  f1 = f1 * f10;
                  f3 = f3 * f14;
                  f6 = f24 + f28;
                  heapClassInst.heapFloat[r11 + numDefine5] = f7;
                  heapClassInst.heapFloat[r11 + numDefine6] = f6;
                  f4 = f4 * f10;
                  f5 = f5 * f14;
                  f1 = f1 + f3;
                  f3 = f9 * f18;
                  f6 = f13 * f10;
                  f7 = f17 * f14;
                  f4 = f4 + f5;
                  f5 = f22 * f18;
                  f1 = f1 + f3;
                  heapClassInst.heap32[r11 + numDefine7] = 0;
                  f0 = f0 * f11;
                  f2 = f2 * f15;
                  f3 = f6 + f7;
                  f6 = f21 * f18;
                  f4 = f4 + f5;
                  heapClassInst.heapFloat[r11 + numDefine8] = f1;
                  f1 = f12 * f11;
                  f5 = f16 * f15;
                  f0 = f0 + f2;
                  f2 = f8 * f19;
                  f3 = f3 + f6;
                  heapClassInst.heapFloat[r11 + numDefine9] = f4;
                  f0 = f0 + f2;
                  heapClassInst.heapFloat[r11 + numDefine10] = f3;
                  f2 = f10 * f11;
                  f3 = f14 * f15;
                  f1 = f1 + f5;
                  f4 = f20 * f19;
                  f1 = f1 + f4;
                  f2 = f2 + f3;
                  f3 = f18 * f19;
                  f0 = f0 + f27;
                  heapClassInst.heap32[r11 + numDefine11] = 0;
                  f2 = f2 + f3;
                  f1 = f1 + f26;
                  heapClassInst.heapFloat[r11 + numDefine12] = f0;
                  f0 = f2 + f25;
                  heapClassInst.heapFloat[r11 + numDefine13] = f1;
                  heapClassInst.heapFloat[r11 + numDefine14] = f0;
                  heapClassInst.heap32[r11 + numDefine15] = 0;
                  if (!(r8 === 0)) {
                    r12 = heapClassInst.heap32[r1];
                    r12 = r12 >> numDefine2;
                    r12 = heapClassInst.heap32[r12 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    functionTable[r12 >> numDefine2](i7);
                    r13 = commonVariable.rg0 >> numDefine2;
                    r13 = heapClassInst.heap32[r13];
                    r13 = r13 >> numDefine2;
                    r13 = heapClassInst.heap32[r13 + numDefine14];
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[g0 + numDefine2] = f0;
                    functionTable[r13 >> numDefine2](i7);
                  }
                  r12 = heapClassInst.heap32[r10 + numDefine6];
                  r12 = r12 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r12 + 1];
                  f1 = heapClassInst.heapFloat[r10 + numDefine88];
                  f2 = heapClassInst.heapFloat[r12 + numDefine2];
                  f3 = heapClassInst.heapFloat[r10 + numDefine92];
                  f4 = heapClassInst.heapFloat[r10 + numDefine89];
                  f5 = heapClassInst.heapFloat[r10 + numDefine93];
                  f6 = f1 * f0;
                  f7 = f3 * f2;
                  f8 = heapClassInst.heapFloat[r12 + numDefine3];
                  f9 = heapClassInst.heapFloat[r10 + numDefine96];
                  f10 = heapClassInst.heapFloat[r12 + numDefine9];
                  f11 = heapClassInst.heapFloat[r10 + numDefine100];
                  f12 = heapClassInst.heapFloat[r12 + numDefine5];
                  f13 = heapClassInst.heapFloat[r10 + numDefine90];
                  f14 = heapClassInst.heapFloat[r12 + numDefine10];
                  f15 = heapClassInst.heapFloat[r10 + numDefine101];
                  f16 = heapClassInst.heapFloat[r12 + numDefine6];
                  f17 = heapClassInst.heapFloat[r10 + numDefine94];
                  f18 = heapClassInst.heapFloat[r12 + numDefine11];
                  f19 = heapClassInst.heapFloat[r10 + numDefine102];
                  f20 = heapClassInst.heapFloat[r12 + numDefine7];
                  f21 = heapClassInst.heapFloat[r10 + numDefine98];
                  f22 = heapClassInst.heapFloat[r10 + numDefine97];
                  f23 = f4 * f0;
                  f24 = f5 * f2;
                  f6 = f6 + f7;
                  f7 = f9 * f8;
                  f25 = heapClassInst.heapFloat[r12 + numDefine15];
                  f26 = heapClassInst.heapFloat[r12 + numDefine14];
                  f27 = heapClassInst.heapFloat[r12 + numDefine13];
                  f28 = f13 * f0;
                  f29 = f17 * f2;
                  f23 = f23 + f24;
                  f24 = f22 * f8;
                  f6 = f6 + f7;
                  f7 = f28 + f29;
                  f28 = f21 * f8;
                  f23 = f23 + f24;
                  heapClassInst.heapFloat[fp + numDefineNeg98] = f6;
                  f6 = f1 * f12;
                  f24 = f3 * f16;
                  f7 = f7 + f28;
                  heapClassInst.heapFloat[r11 + 1] = f23;
                  heapClassInst.heapFloat[r11 + numDefine2] = f7;
                  f7 = f4 * f12;
                  f23 = f5 * f16;
                  f6 = f6 + f24;
                  f24 = f9 * f20;
                  f28 = f13 * f12;
                  f29 = f17 * f16;
                  f7 = f7 + f23;
                  f23 = f22 * f20;
                  f6 = f6 + f24;
                  heapClassInst.heap32[r11 + numDefine3] = 0;
                  f24 = f28 + f29;
                  f28 = f21 * f20;
                  f7 = f7 + f23;
                  heapClassInst.heapFloat[r11 + numDefine4] = f6;
                  f1 = f1 * f10;
                  f3 = f3 * f14;
                  f6 = f24 + f28;
                  heapClassInst.heapFloat[r11 + numDefine5] = f7;
                  heapClassInst.heapFloat[r11 + numDefine6] = f6;
                  f4 = f4 * f10;
                  f5 = f5 * f14;
                  f1 = f1 + f3;
                  f3 = f9 * f18;
                  f6 = f13 * f10;
                  f7 = f17 * f14;
                  f4 = f4 + f5;
                  f5 = f22 * f18;
                  f1 = f1 + f3;
                  heapClassInst.heap32[r11 + numDefine7] = 0;
                  f0 = f0 * f11;
                  f2 = f2 * f15;
                  f3 = f6 + f7;
                  f6 = f21 * f18;
                  f4 = f4 + f5;
                  heapClassInst.heapFloat[r11 + numDefine8] = f1;
                  f1 = f12 * f11;
                  f5 = f16 * f15;
                  f0 = f0 + f2;
                  f2 = f8 * f19;
                  f3 = f3 + f6;
                  heapClassInst.heapFloat[r11 + numDefine9] = f4;
                  f0 = f0 + f2;
                  heapClassInst.heapFloat[r11 + numDefine10] = f3;
                  f2 = f10 * f11;
                  f3 = f14 * f15;
                  f1 = f1 + f5;
                  f4 = f20 * f19;
                  f1 = f1 + f4;
                  f2 = f2 + f3;
                  f3 = f18 * f19;
                  f0 = f0 + f27;
                  heapClassInst.heap32[r11 + numDefine11] = 0;
                  f2 = f2 + f3;
                  f1 = f1 + f26;
                  heapClassInst.heapFloat[r11 + numDefine12] = f0;
                  f0 = f2 + f25;
                  heapClassInst.heapFloat[r11 + numDefine13] = f1;
                  heapClassInst.heapFloat[r11 + numDefine14] = f0;
                  heapClassInst.heap32[r11 + numDefine15] = 0;
                  if (!(r8 === 0)) {
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    functionTable[r8 >> numDefine2](i7);
                    r12 = commonVariable.rg0 >> numDefine2;
                    r12 = heapClassInst.heap32[r12];
                    r12 = r12 >> numDefine2;
                    r12 = heapClassInst.heap32[r12 + numDefine14];
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[g0 + numDefine2] = f0;
                    functionTable[r12 >> numDefine2](i7);
                  }
                  if (r9 === 0) {
                    break repeat7;
                  } else {
                    r8 = sp + numDefineNeg408;
                    heapClassInst.heap32[g0] = r8;
                    heapClassInst.heap32[g0 + 1] = r2;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine06843;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[g0 + numDefine3] = f0;
                    znk21btConeTwistConstraint16GetPointForAngleEff(i7);
                    r9 = r8 >> numDefine2;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg102];
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg98];
                    f2 = heapClassInst.heapFloat[r9 + 1];
                    f3 = heapClassInst.heapFloat[r11 + 1];
                    f4 = heapClassInst.heapFloat[r11 + numDefine4];
                    f5 = heapClassInst.heapFloat[r11 + numDefine5];
                    f1 = f1 * f0;
                    f3 = f3 * f2;
                    f6 = heapClassInst.heapFloat[r9 + numDefine2];
                    f7 = heapClassInst.heapFloat[r11 + numDefine2];
                    f8 = heapClassInst.heapFloat[r11 + numDefine8];
                    f9 = heapClassInst.heapFloat[r11 + numDefine9];
                    f10 = heapClassInst.heapFloat[r11 + numDefine6];
                    f4 = f4 * f0;
                    f5 = f5 * f2;
                    f1 = f1 + f3;
                    f3 = f7 * f6;
                    f7 = heapClassInst.heapFloat[r11 + numDefine10];
                    f0 = f8 * f0;
                    f2 = f9 * f2;
                    f4 = f4 + f5;
                    f5 = f10 * f6;
                    f1 = f1 + f3;
                    f3 = heapClassInst.heapFloat[r11 + numDefine12];
                    f8 = heapClassInst.heapFloat[r11 + numDefine14];
                    f9 = heapClassInst.heapFloat[r11 + numDefine13];
                    f4 = f4 + f5;
                    f0 = f0 + f2;
                    f2 = f7 * f6;
                    f1 = f1 + f3;
                    f0 = f0 + f2;
                    f2 = f4 + f9;
                    heapClassInst.heapFloat[fp + numDefineNeg102] = f1;
                    f0 = f0 + f8;
                    heapClassInst.heapFloat[r9 + 1] = f2;
                    r12 = 0;
                    heapClassInst.heapFloat[r9 + numDefine2] = f0;
                    heapClassInst.heap32[r9 + numDefine3] = 0;
                    repeat20: while (true) {
                      f0 = r12;
                      f1 = numDefineFloat283;
                      f0 = f0 * f1;
                      f1 = numDefine32;
                      r13 = sp + numDefineNeg472;
                      f0 = f0 / f1;
                      heapClassInst.heap32[g0] = r13;
                      heapClassInst.heap32[g0 + 1] = r2;
                      heapClassInst.heapFloat[g0 + numDefine2] = f0;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      heapClassInst.heapFloat[g0 + numDefine3] = f0;
                      znk21btConeTwistConstraint16GetPointForAngleEff(i7);
                      r14 = r13 >> numDefine2;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg118];
                      f1 = heapClassInst.heapFloat[fp + numDefineNeg98];
                      f2 = heapClassInst.heapFloat[r14 + 1];
                      f3 = heapClassInst.heapFloat[r11 + 1];
                      f4 = heapClassInst.heapFloat[r11 + numDefine4];
                      f5 = heapClassInst.heapFloat[r11 + numDefine5];
                      f1 = f1 * f0;
                      f3 = f3 * f2;
                      f6 = heapClassInst.heapFloat[r14 + numDefine2];
                      f7 = heapClassInst.heapFloat[r11 + numDefine2];
                      f8 = heapClassInst.heapFloat[r11 + numDefine8];
                      f9 = heapClassInst.heapFloat[r11 + numDefine9];
                      f10 = heapClassInst.heapFloat[r11 + numDefine6];
                      f4 = f4 * f0;
                      f5 = f5 * f2;
                      f1 = f1 + f3;
                      f3 = f7 * f6;
                      f7 = heapClassInst.heapFloat[r11 + numDefine10];
                      f0 = f8 * f0;
                      f2 = f9 * f2;
                      f4 = f4 + f5;
                      f5 = f10 * f6;
                      f1 = f1 + f3;
                      f3 = heapClassInst.heapFloat[r11 + numDefine12];
                      f8 = heapClassInst.heapFloat[r11 + numDefine14];
                      f9 = heapClassInst.heapFloat[r11 + numDefine13];
                      f4 = f4 + f5;
                      f0 = f0 + f2;
                      f2 = f7 * f6;
                      f1 = f1 + f3;
                      f0 = f0 + f2;
                      f2 = f4 + f9;
                      heapClassInst.heapFloat[fp + numDefineNeg118] = f1;
                      f0 = f0 + f8;
                      heapClassInst.heapFloat[r14 + 1] = f2;
                      heapClassInst.heapFloat[r14 + numDefine2] = f0;
                      heapClassInst.heap32[r14 + numDefine3] = 0;
                      r15 = heapClassInst.heap32[r1];
                      r15 = r15 >> numDefine2;
                      r15 = heapClassInst.heap32[r15 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r15 >> numDefine2](i7);
                      r16 = commonVariable.rg0 >> numDefine2;
                      r16 = heapClassInst.heap32[r16];
                      r16 = r16 >> numDefine2;
                      r16 = heapClassInst.heap32[r16 + numDefine2];
                      r17 = sp + numDefineNeg152;
                      r18 = r17 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg38] = 0;
                      heapClassInst.heap32[r18 + 1] = 0;
                      heapClassInst.heap32[r18 + numDefine2] = 0;
                      heapClassInst.heap32[r18 + numDefine3] = 0;
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r8;
                      heapClassInst.heap32[g0 + numDefine2] = r13;
                      heapClassInst.heap32[g0 + numDefine3] = r17;
                      r15 = r12 & numDefine3;
                      functionTable[r16 >> numDefine2](i7);
                      if (!(r15 !== 0)) {
                        r15 = heapClassInst.heap32[r1];
                        r15 = r15 >> numDefine2;
                        r15 = heapClassInst.heap32[r15 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r15 >> numDefine2](i7);
                        r16 = commonVariable.rg0 >> numDefine2;
                        r16 = heapClassInst.heap32[r16];
                        r16 = r16 >> numDefine2;
                        r16 = heapClassInst.heap32[r16 + numDefine2];
                        r17 = sp + numDefineNeg136;
                        r18 = r17 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg34] = 0;
                        heapClassInst.heap32[r18 + 1] = 0;
                        heapClassInst.heap32[r18 + numDefine2] = 0;
                        heapClassInst.heap32[r18 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r6;
                        heapClassInst.heap32[g0 + numDefine2] = r13;
                        heapClassInst.heap32[g0 + numDefine3] = r17;
                        functionTable[r16 >> numDefine2](i7);
                      }
                      heapClassInst.heap32[fp + numDefineNeg102] = heapClassInst.heap32[fp + numDefineNeg118];
                      heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r14 + 1];
                      r12 = (r12 + 1) | 0;
                      heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r14 + numDefine2];
                      heapClassInst.heap32[r9 + numDefine3] = heapClassInst.heap32[r14 + numDefine3];
                      if (!(r12 !== numDefine32)) {
                        break repeat20;
                      }
                    }
                    r2 = heapClassInst.heap32[r10 + numDefine6];
                    f0 = heapClassInst.heapFloat[r10 + numDefine110];
                    heapClassInst.heapFloat[fp + numDefineNeg193] = f0;
                    f0 = heapClassInst.heapFloat[r10 + numDefine125];
                    heapClassInst.heapFloat[fp + numDefineNeg194] = f0;
                    r2 = r2 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r2 + numDefine84];
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg192];
                    if (f0 <= f1) {
                      r2 = heapClassInst.heap32[r10 + numDefine5];
                      r2 = r2 >> numDefine2;
                      f0 = heapClassInst.heapFloat[r10 + numDefine84];
                      f1 = heapClassInst.heapFloat[r2 + numDefine9];
                      f2 = heapClassInst.heapFloat[r2 + numDefine5];
                      f3 = heapClassInst.heapFloat[r2 + 1];
                      f4 = heapClassInst.heapFloat[r10 + numDefine85];
                      f5 = heapClassInst.heapFloat[r2 + numDefine10];
                      f6 = heapClassInst.heapFloat[r2 + numDefine6];
                      f8 = heapClassInst.heapFloat[r2 + numDefine2];
                      f12 = heapClassInst.heapFloat[r10 + numDefine74];
                      f13 = heapClassInst.heapFloat[r10 + numDefine78];
                      f14 = heapClassInst.heapFloat[r10 + numDefine73];
                      f15 = heapClassInst.heapFloat[r10 + numDefine77];
                      f7 = heapClassInst.heapFloat[r10 + numDefine72];
                      f9 = heapClassInst.heapFloat[r10 + numDefine76];
                      f10 = f1 * f0;
                      f11 = f5 * f4;
                      f16 = f2 * f0;
                      f17 = f6 * f4;
                      f0 = f3 * f0;
                      f4 = f8 * f4;
                      f18 = heapClassInst.heapFloat[r10 + numDefine86];
                      f19 = heapClassInst.heapFloat[r2 + numDefine11];
                      f20 = heapClassInst.heapFloat[r2 + numDefine7];
                      f21 = heapClassInst.heapFloat[r2 + numDefine3];
                      f22 = heapClassInst.heapFloat[r10 + numDefine82];
                      f23 = heapClassInst.heapFloat[r10 + numDefine81];
                      f24 = heapClassInst.heapFloat[r10 + numDefine80];
                      f10 = f10 + f11;
                      f11 = f19 * f18;
                      f16 = f16 + f17;
                      f17 = f20 * f18;
                      f0 = f0 + f4;
                      heapClassInst.heapFloat[fp + numDefineNeg192] = f0;
                      f4 = f21 * f18;
                      f18 = f12 * f1;
                      f25 = f13 * f5;
                      f26 = f14 * f1;
                      f27 = f15 * f5;
                      f1 = f7 * f1;
                      f5 = f9 * f5;
                      f28 = f12 * f2;
                      f29 = f13 * f6;
                      f30 = f14 * f2;
                      f0 = f15 * f6;
                      f2 = f7 * f2;
                      f6 = f9 * f6;
                      f12 = f12 * f3;
                      f13 = f13 * f8;
                      f14 = f14 * f3;
                      f15 = f15 * f8;
                      f3 = f7 * f3;
                      f8 = f9 * f8;
                      f7 = f10 + f11;
                      f9 = heapClassInst.heapFloat[r2 + numDefine15];
                      f10 = f16 + f17;
                      f11 = heapClassInst.heapFloat[r2 + numDefine14];
                      f16 = heapClassInst.heapFloat[fp + numDefineNeg192];
                      f4 = f16 + f4;
                      f16 = heapClassInst.heapFloat[r2 + numDefine13];
                      f17 = f18 + f25;
                      f18 = f22 * f19;
                      f25 = f26 + f27;
                      f26 = f23 * f19;
                      f1 = f1 + f5;
                      f5 = f24 * f19;
                      f19 = f28 + f29;
                      f27 = f22 * f20;
                      f0 = f30 + f0;
                      f28 = f23 * f20;
                      f2 = f2 + f6;
                      f6 = f24 * f20;
                      f20 = f12 + f13;
                      f22 = f22 * f21;
                      f29 = f14 + f15;
                      f23 = f23 * f21;
                      f3 = f3 + f8;
                      f21 = f24 * f21;
                      f12 = f7 + f9;
                      f13 = f10 + f11;
                      f4 = f4 + f16;
                      f14 = f17 + f18;
                      f15 = f25 + f26;
                      f1 = f1 + f5;
                      f5 = f19 + f27;
                      f0 = f0 + f28;
                      f2 = f2 + f6;
                      f6 = f20 + f22;
                      f8 = f29 + f23;
                      f3 = f3 + f21;
                    } else {
                      f0 = heapClassInst.heapFloat[r10 + numDefine100];
                      f1 = heapClassInst.heapFloat[r2 + numDefine9];
                      f2 = heapClassInst.heapFloat[r2 + numDefine5];
                      f3 = heapClassInst.heapFloat[r2 + 1];
                      f4 = heapClassInst.heapFloat[r10 + numDefine101];
                      f5 = heapClassInst.heapFloat[r2 + numDefine10];
                      f6 = heapClassInst.heapFloat[r2 + numDefine6];
                      f7 = heapClassInst.heapFloat[r2 + numDefine2];
                      f8 = heapClassInst.heapFloat[r10 + numDefine90];
                      f9 = heapClassInst.heapFloat[r10 + numDefine94];
                      f10 = heapClassInst.heapFloat[r10 + numDefine89];
                      f11 = heapClassInst.heapFloat[r10 + numDefine93];
                      f12 = heapClassInst.heapFloat[r10 + numDefine88];
                      f13 = heapClassInst.heapFloat[r10 + numDefine92];
                      f14 = f1 * f0;
                      f15 = f5 * f4;
                      f16 = f2 * f0;
                      f17 = f6 * f4;
                      f0 = f3 * f0;
                      f4 = f7 * f4;
                      f18 = heapClassInst.heapFloat[r10 + numDefine102];
                      f19 = heapClassInst.heapFloat[r2 + numDefine11];
                      f20 = heapClassInst.heapFloat[r2 + numDefine7];
                      f21 = heapClassInst.heapFloat[r2 + numDefine3];
                      f22 = heapClassInst.heapFloat[r10 + numDefine98];
                      f23 = heapClassInst.heapFloat[r10 + numDefine97];
                      f24 = heapClassInst.heapFloat[r10 + numDefine96];
                      f14 = f14 + f15;
                      f15 = f19 * f18;
                      f16 = f16 + f17;
                      f17 = f20 * f18;
                      f0 = f0 + f4;
                      heapClassInst.heapFloat[fp + numDefineNeg192] = f0;
                      f4 = f21 * f18;
                      f18 = f8 * f1;
                      f25 = f9 * f5;
                      f26 = f10 * f1;
                      f27 = f11 * f5;
                      f1 = f12 * f1;
                      f5 = f13 * f5;
                      f28 = f8 * f2;
                      f29 = f9 * f6;
                      f30 = f10 * f2;
                      f0 = f11 * f6;
                      f2 = f12 * f2;
                      f6 = f13 * f6;
                      f8 = f8 * f3;
                      f9 = f9 * f7;
                      f10 = f10 * f3;
                      f11 = f11 * f7;
                      f3 = f12 * f3;
                      f7 = f13 * f7;
                      f12 = f14 + f15;
                      f13 = heapClassInst.heapFloat[r2 + numDefine15];
                      f14 = f16 + f17;
                      f15 = heapClassInst.heapFloat[r2 + numDefine14];
                      f16 = heapClassInst.heapFloat[fp + numDefineNeg192];
                      f4 = f16 + f4;
                      f16 = heapClassInst.heapFloat[r2 + numDefine13];
                      f17 = f18 + f25;
                      f18 = f22 * f19;
                      f25 = f26 + f27;
                      f26 = f23 * f19;
                      f1 = f1 + f5;
                      f5 = f24 * f19;
                      f19 = f28 + f29;
                      f27 = f22 * f20;
                      f0 = f30 + f0;
                      f28 = f23 * f20;
                      f2 = f2 + f6;
                      f6 = f24 * f20;
                      f8 = f8 + f9;
                      f9 = f22 * f21;
                      f10 = f10 + f11;
                      f11 = f23 * f21;
                      f3 = f3 + f7;
                      f7 = f24 * f21;
                      f12 = f12 + f13;
                      f13 = f14 + f15;
                      f4 = f4 + f16;
                      f14 = f17 + f18;
                      f15 = f25 + f26;
                      f1 = f1 + f5;
                      f5 = f19 + f27;
                      f0 = f0 + f28;
                      f2 = f2 + f6;
                      f6 = f8 + f9;
                      f8 = f10 + f11;
                      f3 = f3 + f7;
                    }
                    heapClassInst.heapFloat[fp + numDefineNeg98] = f3;
                    heapClassInst.heapFloat[r11 + 1] = f8;
                    heapClassInst.heapFloat[r11 + numDefine2] = f6;
                    heapClassInst.heap32[r11 + numDefine3] = 0;
                    heapClassInst.heapFloat[r11 + numDefine4] = f2;
                    heapClassInst.heapFloat[r11 + numDefine5] = f0;
                    heapClassInst.heapFloat[r11 + numDefine6] = f5;
                    heapClassInst.heap32[r11 + numDefine7] = 0;
                    heapClassInst.heapFloat[r11 + numDefine8] = f1;
                    heapClassInst.heapFloat[r11 + numDefine9] = f15;
                    heapClassInst.heapFloat[r11 + numDefine10] = f14;
                    heapClassInst.heap32[r11 + numDefine11] = 0;
                    heapClassInst.heapFloat[r11 + numDefine12] = f4;
                    heapClassInst.heapFloat[r11 + numDefine13] = f13;
                    heapClassInst.heapFloat[r11 + numDefine14] = f12;
                    r2 = sp + numDefineNeg424;
                    heapClassInst.heap32[r11 + numDefine15] = 0;
                    r8 = r2 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg106] = f4;
                    heapClassInst.heapFloat[r8 + 1] = f13;
                    heapClassInst.heapFloat[r8 + numDefine2] = f12;
                    r9 = sp + numDefineNeg440;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    r8 = r9 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg110] = f3;
                    heapClassInst.heapFloat[r8 + 1] = f2;
                    heapClassInst.heapFloat[r8 + numDefine2] = f1;
                    r10 = sp + numDefineNeg456;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    r8 = r10 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg114] = f8;
                    heapClassInst.heapFloat[r8 + 1] = f0;
                    heapClassInst.heapFloat[r8 + numDefine2] = f15;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    functionTable[r8 >> numDefine2](i7);
                    r11 = commonVariable.rg0 >> numDefine2;
                    r11 = heapClassInst.heap32[r11];
                    r11 = r11 >> numDefine2;
                    r11 = heapClassInst.heap32[r11 + numDefine15];
                    r12 = sp + numDefineNeg120;
                    r13 = r12 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg30] = 0;
                    heapClassInst.heap32[r13 + 1] = 0;
                    heapClassInst.heap32[r13 + numDefine2] = 0;
                    heapClassInst.heap32[r13 + numDefine3] = 0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg194];
                    f1 = -f0;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg193];
                    f1 = f1 - f2;
                    f0 = f2 - f0;
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r2;
                    heapClassInst.heap32[g0 + numDefine2] = r9;
                    heapClassInst.heap32[g0 + numDefine3] = r10;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[g0 + numDefine4] = f2;
                    heapClassInst.heapFloat[g0 + numDefine5] = f2;
                    heapClassInst.heapFloat[g0 + numDefine6] = f1;
                    heapClassInst.heapFloat[g0 + numDefine7] = f0;
                    heapClassInst.heap32[g0 + numDefine8] = r12;
                    heapClassInst.heap32[g0 + numDefine9] = 1;
                    heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                    functionTable[r11 >> numDefine2](i7);
                  }
                } else {
                  if (r11 === numDefine6) {
                    r11 = sp + numDefineNeg536;
                    r12 = r11 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine263];
                    heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                    heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine265];
                    heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                    heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine267];
                    heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                    heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine269];
                    heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                    heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine271];
                    heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                    heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine273];
                    heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                    heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                    heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                    heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                    heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                    if (!(r8 === 0)) {
                      r13 = heapClassInst.heap32[r1];
                      r13 = r13 >> numDefine2;
                      r13 = heapClassInst.heap32[r13 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r13 >> numDefine2](i7);
                      r14 = commonVariable.rg0 >> numDefine2;
                      r14 = heapClassInst.heap32[r14];
                      r14 = r14 >> numDefine2;
                      r14 = heapClassInst.heap32[r14 + numDefine14];
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r11;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      heapClassInst.heapFloat[g0 + numDefine2] = f0;
                      functionTable[r14 >> numDefine2](i7);
                    }
                    heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine279];
                    heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine280];
                    heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine281];
                    heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine282];
                    heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine283];
                    heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine284];
                    heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine285];
                    heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine286];
                    heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine287];
                    heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine288];
                    heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine289];
                    heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine290];
                    heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine291];
                    heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine292];
                    heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine293];
                    heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine294];
                    if (!(r8 === 0)) {
                      r8 = heapClassInst.heap32[r1];
                      r8 = r8 >> numDefine2;
                      r8 = heapClassInst.heap32[r8 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r8 >> numDefine2](i7);
                      r13 = commonVariable.rg0 >> numDefine2;
                      r13 = heapClassInst.heap32[r13];
                      r13 = r13 >> numDefine2;
                      r13 = heapClassInst.heap32[r13 + numDefine14];
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r11;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      heapClassInst.heapFloat[g0 + numDefine2] = f0;
                      functionTable[r13 >> numDefine2](i7);
                    }
                    if (r9 === 0) {
                      break repeat7;
                    } else {
                      r2 = (r2 + numDefine1164) | 0;
                      f0 = heapClassInst.heapFloat[r10 + numDefine263];
                      heapClassInst.heapFloat[fp + numDefineNeg134] = f0;
                      heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                      f1 = heapClassInst.heapFloat[r10 + numDefine265];
                      heapClassInst.heapFloat[r12 + numDefine2] = f1;
                      heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                      f2 = heapClassInst.heapFloat[r10 + numDefine267];
                      heapClassInst.heapFloat[r12 + numDefine4] = f2;
                      heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                      f3 = heapClassInst.heapFloat[r10 + numDefine269];
                      heapClassInst.heapFloat[r12 + numDefine6] = f3;
                      heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                      f4 = heapClassInst.heapFloat[r10 + numDefine271];
                      heapClassInst.heapFloat[r12 + numDefine8] = f4;
                      heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                      f5 = heapClassInst.heapFloat[r10 + numDefine273];
                      heapClassInst.heapFloat[r12 + numDefine10] = f5;
                      heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                      heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                      heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                      heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                      r8 = sp + numDefineNeg552;
                      heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                      r9 = r8 >> numDefine2;
                      heapClassInst.heapFloat[fp + numDefineNeg138] = f1;
                      heapClassInst.heapFloat[r9 + 1] = f3;
                      heapClassInst.heapFloat[r9 + numDefine2] = f5;
                      heapClassInst.heap32[r9 + numDefine3] = 0;
                      r9 = sp + numDefineNeg568;
                      heapClassInst.heapFloat[fp + numDefineNeg142] = f0;
                      r13 = r9 >> numDefine2;
                      heapClassInst.heapFloat[r13 + 1] = f2;
                      heapClassInst.heapFloat[r13 + numDefine2] = f4;
                      heapClassInst.heap32[r13 + numDefine3] = 0;
                      r14 = heapClassInst.heap32[r1];
                      r14 = r14 >> numDefine2;
                      r14 = heapClassInst.heap32[r14 + numDefine4];
                      f0 = heapClassInst.heapFloat[r10 + numDefine230];
                      f1 = heapClassInst.heapFloat[r10 + numDefine231];
                      f2 = heapClassInst.heapFloat[r10 + numDefine246];
                      f3 = heapClassInst.heapFloat[r10 + numDefine247];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r14 >> numDefine2](i7);
                      r15 = commonVariable.rg0 >> numDefine2;
                      r15 = heapClassInst.heap32[r15];
                      r15 = r15 >> numDefine2;
                      r15 = heapClassInst.heap32[r15 + numDefine16];
                      r16 = sp + numDefineNeg104;
                      r17 = r16 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg26] = 0;
                      heapClassInst.heap32[r17 + 1] = 0;
                      heapClassInst.heap32[r17 + numDefine2] = 0;
                      heapClassInst.heap32[r17 + numDefine3] = 0;
                      f4 = numDefineFloat809;
                      f5 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      f4 = f5 * f4;
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r2;
                      heapClassInst.heap32[g0 + numDefine2] = r8;
                      heapClassInst.heap32[g0 + numDefine3] = r9;
                      heapClassInst.heapFloat[g0 + numDefine4] = f4;
                      heapClassInst.heapFloat[g0 + numDefine5] = f0;
                      heapClassInst.heapFloat[g0 + numDefine6] = f1;
                      heapClassInst.heapFloat[g0 + numDefine7] = f2;
                      heapClassInst.heapFloat[g0 + numDefine8] = f3;
                      heapClassInst.heap32[g0 + numDefine9] = r16;
                      heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                      functionTable[r15 >> numDefine2](i7);
                      f0 = heapClassInst.heapFloat[r12 + numDefine9];
                      f1 = heapClassInst.heapFloat[r12 + numDefine5];
                      heapClassInst.heap32[fp + numDefineNeg142] = heapClassInst.heap32[r12 + 1];
                      heapClassInst.heapFloat[r13 + 1] = f1;
                      heapClassInst.heapFloat[r13 + numDefine2] = f0;
                      heapClassInst.heap32[r13 + numDefine3] = 0;
                      f0 = heapClassInst.heapFloat[r10 + numDefine296];
                      f1 = heapClassInst.heapFloat[r10 + numDefine297];
                      heapClassInst.heapFloat[g0] = f0;
                      cosf(i7);
                      f2 = commonVariable.fg0;
                      heapClassInst.heapFloat[g0] = f0;
                      sinf(i7);
                      f0 = commonVariable.fg0;
                      heapClassInst.heapFloat[g0] = f1;
                      cosf(i7);
                      f3 = commonVariable.fg0;
                      heapClassInst.heapFloat[g0] = f1;
                      sinf(i7);
                      f4 = heapClassInst.heapFloat[fp + numDefineNeg142];
                      f5 = f2 * f3;
                      f6 = heapClassInst.heapFloat[r13 + 1];
                      f7 = f2 * commonVariable.fg0;
                      f8 = heapClassInst.heapFloat[r13 + numDefine2];
                      f5 = f5 * f4;
                      f7 = f7 * f6;
                      f9 = f3 * f0;
                      f10 = commonVariable.fg0 * f0;
                      f5 = f5 + f7;
                      f0 = f8 * f0;
                      r8 = sp + numDefineNeg584;
                      f7 = f9 * f4;
                      f9 = f10 * f6;
                      f3 = f6 * f3;
                      f1 = f4 * commonVariable.fg0;
                      f0 = f5 - f0;
                      r9 = r8 >> numDefine2;
                      f4 = f7 + f9;
                      f2 = f8 * f2;
                      f1 = f3 - f1;
                      heapClassInst.heapFloat[fp + numDefineNeg146] = f0;
                      f0 = f4 + f2;
                      heapClassInst.heapFloat[r9 + 1] = f1;
                      heapClassInst.heapFloat[r9 + numDefine2] = f0;
                      f0 = heapClassInst.heapFloat[r10 + numDefine279];
                      heapClassInst.heapFloat[fp + numDefineNeg134] = f0;
                      heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine280];
                      heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine281];
                      heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine282];
                      f1 = heapClassInst.heapFloat[r10 + numDefine283];
                      heapClassInst.heapFloat[r12 + numDefine4] = f1;
                      heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine284];
                      heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine285];
                      heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine286];
                      f2 = heapClassInst.heapFloat[r10 + numDefine287];
                      heapClassInst.heapFloat[r12 + numDefine8] = f2;
                      heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine288];
                      heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine289];
                      heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine290];
                      heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine291];
                      heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine292];
                      heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine293];
                      r9 = sp + numDefineNeg600;
                      f0 = -f0;
                      heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine294];
                      r13 = r9 >> numDefine2;
                      f1 = -f1;
                      heapClassInst.heapFloat[fp + numDefineNeg150] = f0;
                      f0 = -f2;
                      heapClassInst.heapFloat[r13 + 1] = f1;
                      heapClassInst.heapFloat[r13 + numDefine2] = f0;
                      heapClassInst.heap32[r13 + numDefine3] = 0;
                      f0 = heapClassInst.heapFloat[r10 + numDefine214];
                      f1 = heapClassInst.heapFloat[r10 + numDefine215];
                      if (f0 <= f1) {
                        if (!(f0 >= f1)) {
                          r13 = heapClassInst.heap32[r1];
                          r13 = r13 >> numDefine2;
                          r13 = heapClassInst.heap32[r13 + numDefine4];
                          heapClassInst.heap32[g0] = r0;
                          functionTable[r13 >> numDefine2](i7);
                          r14 = commonVariable.rg0 >> numDefine2;
                          r14 = heapClassInst.heap32[r14];
                          r14 = r14 >> numDefine2;
                          r14 = heapClassInst.heap32[r14 + numDefine15];
                          r15 = sp + numDefineNeg72;
                          r16 = r15 >> numDefine2;
                          heapClassInst.heap32[fp + numDefineNeg18] = 0;
                          heapClassInst.heap32[r16 + 1] = 0;
                          heapClassInst.heap32[r16 + numDefine2] = 0;
                          heapClassInst.heap32[r16 + numDefine3] = 0;
                          heapClassInst.heap32[g0] = commonVariable.rg0;
                          heapClassInst.heap32[g0 + 1] = r2;
                          heapClassInst.heap32[g0 + numDefine2] = r9;
                          heapClassInst.heap32[g0 + numDefine3] = r8;
                          f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                          heapClassInst.heapFloat[g0 + numDefine4] = f2;
                          heapClassInst.heapFloat[g0 + numDefine5] = f2;
                          heapClassInst.heapFloat[g0 + numDefine6] = f0;
                          heapClassInst.heapFloat[g0 + numDefine7] = f1;
                          heapClassInst.heap32[g0 + numDefine8] = r15;
                          heapClassInst.heap32[g0 + numDefine9] = 1;
                          heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                          functionTable[r14 >> numDefine2](i7);
                        }
                      } else {
                        r13 = heapClassInst.heap32[r1];
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r13 >> numDefine2](i7);
                        r14 = commonVariable.rg0 >> numDefine2;
                        r14 = heapClassInst.heap32[r14];
                        r14 = r14 >> numDefine2;
                        r14 = heapClassInst.heap32[r14 + numDefine15];
                        r15 = sp + numDefineNeg88;
                        r16 = r15 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg22] = 0;
                        heapClassInst.heap32[r16 + 1] = 0;
                        heapClassInst.heap32[r16 + numDefine2] = 0;
                        heapClassInst.heap32[r16 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        heapClassInst.heap32[g0 + numDefine3] = r8;
                        f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                        heapClassInst.heapFloat[g0 + numDefine4] = f0;
                        heapClassInst.heapFloat[g0 + numDefine5] = f0;
                        heapClassInst.heap32[g0 + numDefine6] = numDefineNeg53637;
                        heapClassInst.heap32[g0 + numDefine7] = numDefine30011;
                        heapClassInst.heap32[g0 + numDefine8] = r15;
                        heapClassInst.heap32[g0 + numDefine9] = 0;
                        heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                        functionTable[r14 >> numDefine2](i7);
                      }
                      heapClassInst.heap32[fp + numDefineNeg134] = heapClassInst.heap32[r10 + numDefine263];
                      heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine264];
                      heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine265];
                      heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine266];
                      heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine267];
                      heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine268];
                      heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine269];
                      heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine270];
                      heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine271];
                      heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine272];
                      heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine273];
                      heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine274];
                      heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine275];
                      heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine276];
                      heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine277];
                      r2 = sp + numDefineNeg616;
                      heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine278];
                      r8 = r2 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg154] = heapClassInst.heap32[r10 + numDefine167];
                      heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r10 + numDefine168];
                      heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r10 + numDefine169];
                      r9 = sp + numDefineNeg632;
                      heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r10 + numDefine170];
                      r8 = r9 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg158] = heapClassInst.heap32[r10 + numDefine171];
                      heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r10 + numDefine172];
                      heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r10 + numDefine173];
                      heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r10 + numDefine174];
                      r8 = heapClassInst.heap32[r1];
                      r8 = r8 >> numDefine2;
                      r8 = heapClassInst.heap32[r8 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r8 >> numDefine2](i7);
                      r10 = commonVariable.rg0 >> numDefine2;
                      r10 = heapClassInst.heap32[r10];
                      r10 = r10 >> numDefine2;
                      r10 = heapClassInst.heap32[r10 + numDefine18];
                      r12 = sp + numDefineNeg56;
                      r13 = r12 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg14] = 0;
                      heapClassInst.heap32[r13 + 1] = 0;
                      heapClassInst.heap32[r13 + numDefine2] = 0;
                      heapClassInst.heap32[r13 + numDefine3] = 0;
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r2;
                      heapClassInst.heap32[g0 + numDefine2] = r9;
                      heapClassInst.heap32[g0 + numDefine3] = r11;
                      heapClassInst.heap32[g0 + numDefine4] = r12;
                      functionTable[r10 >> numDefine2](i7);
                    }
                  } else {
                    if (r11 === numDefine7) {
                      r11 = sp + numDefineNeg696;
                      r12 = r11 >> numDefine2;
                      heapClassInst.heap32[fp + numDefineNeg174] = heapClassInst.heap32[r10 + numDefine203];
                      heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine204];
                      heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine205];
                      heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine206];
                      heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine207];
                      heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine208];
                      heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine209];
                      heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine210];
                      heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine211];
                      heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine212];
                      heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine213];
                      heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine214];
                      heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine215];
                      heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine216];
                      heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine217];
                      heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine218];
                      if (!(r8 === 0)) {
                        r13 = heapClassInst.heap32[r1];
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r13 >> numDefine2](i7);
                        r14 = commonVariable.rg0 >> numDefine2;
                        r14 = heapClassInst.heap32[r14];
                        r14 = r14 >> numDefine2;
                        r14 = heapClassInst.heap32[r14 + numDefine14];
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r11;
                        f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                        heapClassInst.heapFloat[g0 + numDefine2] = f0;
                        functionTable[r14 >> numDefine2](i7);
                      }
                      heapClassInst.heap32[fp + numDefineNeg174] = heapClassInst.heap32[r10 + numDefine219];
                      heapClassInst.heap32[r12 + 1] = heapClassInst.heap32[r10 + numDefine220];
                      heapClassInst.heap32[r12 + numDefine2] = heapClassInst.heap32[r10 + numDefine221];
                      heapClassInst.heap32[r12 + numDefine3] = heapClassInst.heap32[r10 + numDefine222];
                      heapClassInst.heap32[r12 + numDefine4] = heapClassInst.heap32[r10 + numDefine223];
                      heapClassInst.heap32[r12 + numDefine5] = heapClassInst.heap32[r10 + numDefine224];
                      heapClassInst.heap32[r12 + numDefine6] = heapClassInst.heap32[r10 + numDefine225];
                      heapClassInst.heap32[r12 + numDefine7] = heapClassInst.heap32[r10 + numDefine226];
                      heapClassInst.heap32[r12 + numDefine8] = heapClassInst.heap32[r10 + numDefine227];
                      heapClassInst.heap32[r12 + numDefine9] = heapClassInst.heap32[r10 + numDefine228];
                      heapClassInst.heap32[r12 + numDefine10] = heapClassInst.heap32[r10 + numDefine229];
                      heapClassInst.heap32[r12 + numDefine11] = heapClassInst.heap32[r10 + numDefine230];
                      heapClassInst.heap32[r12 + numDefine12] = heapClassInst.heap32[r10 + numDefine231];
                      heapClassInst.heap32[r12 + numDefine13] = heapClassInst.heap32[r10 + numDefine232];
                      heapClassInst.heap32[r12 + numDefine14] = heapClassInst.heap32[r10 + numDefine233];
                      heapClassInst.heap32[r12 + numDefine15] = heapClassInst.heap32[r10 + numDefine234];
                      if (!(r8 === 0)) {
                        r8 = heapClassInst.heap32[r1];
                        r8 = r8 >> numDefine2;
                        r8 = heapClassInst.heap32[r8 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r8 >> numDefine2](i7);
                        r12 = commonVariable.rg0 >> numDefine2;
                        r12 = heapClassInst.heap32[r12];
                        r12 = r12 >> numDefine2;
                        r12 = heapClassInst.heap32[r12 + numDefine14];
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r11;
                        f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                        heapClassInst.heapFloat[g0 + numDefine2] = f0;
                        functionTable[r12 >> numDefine2](i7);
                      }
                      if (r9 === 0) {
                        break repeat7;
                      } else {
                        r8 = (r2 + numDefine924) | 0;
                        r9 = heapClassInst.heapU8[r2 + numDefine168];
                        if (r9 === 0) {
                          r2 = (r2 + numDefine876) | 0;
                        } else {
                          r2 = (r2 + numDefine812) | 0;
                        }
                        r2 = r2 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r2 + 1];
                        f1 = heapClassInst.heapFloat[r10 + numDefine43];
                        f2 = heapClassInst.heapFloat[r2];
                        f3 = heapClassInst.heapFloat[r2 + numDefine2];
                        f4 = heapClassInst.heapFloat[r2 + numDefine5];
                        f5 = heapClassInst.heapFloat[r2 + numDefine4];
                        f6 = f2 * f1;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg192];
                        f8 = f0 * f7;
                        f9 = heapClassInst.heapFloat[r2 + numDefine6];
                        f10 = heapClassInst.heapFloat[r2 + numDefine9];
                        f11 = heapClassInst.heapFloat[r2 + numDefine8];
                        f12 = f5 * f1;
                        f13 = f4 * f7;
                        f6 = f6 + f8;
                        f3 = f3 * f7;
                        f14 = heapClassInst.heapFloat[r2 + numDefine10];
                        f1 = f11 * f1;
                        f15 = f10 * f7;
                        f12 = f12 + f13;
                        f9 = f9 * f7;
                        f6 = f6 + f3;
                        f16 = heapClassInst.heapFloat[r2 + numDefine12];
                        f17 = heapClassInst.heapFloat[r2 + numDefine13];
                        f18 = heapClassInst.heapFloat[r2 + numDefine14];
                        r2 = sp + numDefineNeg712;
                        f12 = f12 + f9;
                        f1 = f1 + f15;
                        f7 = f14 * f7;
                        f6 = f6 + f16;
                        f1 = f1 + f7;
                        r9 = r2 >> numDefine2;
                        f12 = f12 + f17;
                        heapClassInst.heapFloat[fp + numDefineNeg178] = f6;
                        f1 = f1 + f18;
                        heapClassInst.heapFloat[r9 + 1] = f12;
                        heapClassInst.heapFloat[r9 + numDefine2] = f1;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        f1 = heapClassInst.heapFloat[r10 + numDefine44];
                        f6 = f2 * f1;
                        f12 = f5 * f1;
                        f6 = f6 + f8;
                        f1 = f11 * f1;
                        f8 = f12 + f13;
                        f3 = f6 + f3;
                        r9 = sp + numDefineNeg728;
                        f1 = f1 + f15;
                        f6 = f8 + f9;
                        f3 = f3 + f16;
                        f1 = f1 + f7;
                        r11 = r9 >> numDefine2;
                        f6 = f6 + f17;
                        heapClassInst.heapFloat[fp + numDefineNeg182] = f3;
                        f1 = f1 + f18;
                        heapClassInst.heapFloat[r11 + 1] = f6;
                        heapClassInst.heapFloat[r11 + numDefine2] = f1;
                        heapClassInst.heap32[r11 + numDefine3] = 0;
                        r11 = heapClassInst.heap32[r1];
                        r11 = r11 >> numDefine2;
                        r11 = heapClassInst.heap32[r11 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r11 >> numDefine2](i7);
                        r12 = commonVariable.rg0 >> numDefine2;
                        r12 = heapClassInst.heap32[r12];
                        r12 = r12 >> numDefine2;
                        r12 = heapClassInst.heap32[r12 + numDefine2];
                        r13 = sp + numDefineNeg40;
                        r14 = r13 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg10] = 0;
                        heapClassInst.heap32[r14 + 1] = 0;
                        heapClassInst.heap32[r14 + numDefine2] = 0;
                        heapClassInst.heap32[r14 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        heapClassInst.heap32[g0 + numDefine3] = r13;
                        functionTable[r12 >> numDefine2](i7);
                        r2 = sp + numDefineNeg744;
                        r9 = r2 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg186] = f2;
                        heapClassInst.heapFloat[r9 + 1] = f5;
                        heapClassInst.heapFloat[r9 + numDefine2] = f11;
                        r11 = sp + numDefineNeg760;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        r9 = r11 >> numDefine2;
                        heapClassInst.heapFloat[fp + numDefineNeg190] = f0;
                        heapClassInst.heapFloat[r9 + 1] = f4;
                        heapClassInst.heapFloat[r9 + numDefine2] = f10;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        r9 = heapClassInst.heap32[r1];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine4];
                        f0 = heapClassInst.heapFloat[r10 + numDefine45];
                        f1 = heapClassInst.heapFloat[r10 + numDefine46];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r9 >> numDefine2](i7);
                        r10 = commonVariable.rg0 >> numDefine2;
                        r10 = heapClassInst.heap32[r10];
                        r10 = r10 >> numDefine2;
                        r10 = heapClassInst.heap32[r10 + numDefine15];
                        r12 = sp + numDefineNeg24;
                        r13 = r12 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg6] = 0;
                        heapClassInst.heap32[r13 + 1] = 0;
                        heapClassInst.heap32[r13 + numDefine2] = 0;
                        heapClassInst.heap32[r13 + numDefine3] = 0;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r8;
                        heapClassInst.heap32[g0 + numDefine2] = r2;
                        heapClassInst.heap32[g0 + numDefine3] = r11;
                        f2 = heapClassInst.heapFloat[fp + numDefineNeg191];
                        heapClassInst.heapFloat[g0 + numDefine4] = f2;
                        heapClassInst.heapFloat[g0 + numDefine5] = f2;
                        heapClassInst.heapFloat[g0 + numDefine6] = f0;
                        heapClassInst.heapFloat[g0 + numDefine7] = f1;
                        heapClassInst.heap32[g0 + numDefine8] = r12;
                        heapClassInst.heap32[g0 + numDefine9] = 1;
                        heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                        functionTable[r10 >> numDefine2](i7);
                      }
                    } else {
                      break repeat7;
                    }
                  }
                }
              } else {
                if (r11 === numDefine3) {
                  r2 = sp + numDefineNeg232;
                  r9 = r2 >> numDefine2;
                  heapClassInst.heap32[fp + numDefineNeg58] = numDefine53216;
                  heapClassInst.heap32[r9 + 1] = 0;
                  heapClassInst.heap32[r9 + numDefine2] = 0;
                  heapClassInst.heap32[r9 + numDefine3] = 0;
                  heapClassInst.heap32[r9 + numDefine4] = 0;
                  heapClassInst.heap32[r9 + numDefine5] = numDefine53216;
                  heapClassInst.heap32[r9 + numDefine6] = 0;
                  heapClassInst.heap32[r9 + numDefine7] = 0;
                  heapClassInst.heap32[r9 + numDefine8] = 0;
                  heapClassInst.heap32[r9 + numDefine9] = 0;
                  heapClassInst.heap32[r9 + numDefine10] = numDefine53216;
                  heapClassInst.heap32[r9 + numDefine11] = 0;
                  heapClassInst.heap32[r9 + numDefine12] = 0;
                  heapClassInst.heap32[r9 + numDefine13] = 0;
                  heapClassInst.heap32[r9 + numDefine14] = 0;
                  heapClassInst.heap32[r9 + numDefine15] = 0;
                  r11 = heapClassInst.heap32[r10 + numDefine5];
                  r11 = r11 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r10 + numDefine72];
                  f1 = heapClassInst.heapFloat[r11 + 1];
                  f2 = heapClassInst.heapFloat[r10 + numDefine73];
                  f3 = heapClassInst.heapFloat[r11 + numDefine2];
                  f4 = heapClassInst.heapFloat[r11 + numDefine5];
                  f5 = heapClassInst.heapFloat[r11 + numDefine6];
                  f1 = f1 * f0;
                  f3 = f3 * f2;
                  f6 = heapClassInst.heapFloat[r10 + numDefine74];
                  f7 = heapClassInst.heapFloat[r11 + numDefine3];
                  f8 = heapClassInst.heapFloat[r11 + numDefine9];
                  f9 = heapClassInst.heapFloat[r11 + numDefine10];
                  f10 = heapClassInst.heapFloat[r11 + numDefine7];
                  f4 = f4 * f0;
                  f5 = f5 * f2;
                  f1 = f1 + f3;
                  f3 = f7 * f6;
                  f7 = heapClassInst.heapFloat[r11 + numDefine11];
                  f0 = f8 * f0;
                  f2 = f9 * f2;
                  f4 = f4 + f5;
                  f5 = f10 * f6;
                  f1 = f1 + f3;
                  f3 = heapClassInst.heapFloat[r11 + numDefine13];
                  f8 = heapClassInst.heapFloat[r11 + numDefine15];
                  f9 = heapClassInst.heapFloat[r11 + numDefine14];
                  f4 = f4 + f5;
                  f0 = f0 + f2;
                  f2 = f7 * f6;
                  f1 = f1 + f3;
                  f0 = f0 + f2;
                  f2 = f4 + f9;
                  heapClassInst.heapFloat[r9 + numDefine12] = f1;
                  f0 = f0 + f8;
                  heapClassInst.heapFloat[r9 + numDefine13] = f2;
                  heapClassInst.heapFloat[r9 + numDefine14] = f0;
                  heapClassInst.heap32[r9 + numDefine15] = 0;
                  r11 = heapClassInst.heap32[r1];
                  r11 = r11 >> numDefine2;
                  r11 = heapClassInst.heap32[r11 + numDefine4];
                  heapClassInst.heap32[g0] = r0;
                  functionTable[r11 >> numDefine2](i7);
                  r12 = commonVariable.rg0 >> numDefine2;
                  r12 = heapClassInst.heap32[r12];
                  r12 = r12 >> numDefine2;
                  r12 = heapClassInst.heap32[r12 + numDefine14];
                  heapClassInst.heap32[g0] = commonVariable.rg0;
                  heapClassInst.heap32[g0 + 1] = r2;
                  f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                  heapClassInst.heapFloat[g0 + numDefine2] = f0;
                  functionTable[r12 >> numDefine2](i7);
                  r11 = heapClassInst.heap32[r10 + numDefine6];
                  r11 = r11 >> numDefine2;
                  f0 = heapClassInst.heapFloat[r10 + numDefine76];
                  f1 = heapClassInst.heapFloat[r11 + 1];
                  f2 = heapClassInst.heapFloat[r10 + numDefine77];
                  f3 = heapClassInst.heapFloat[r11 + numDefine2];
                  f4 = heapClassInst.heapFloat[r11 + numDefine5];
                  f5 = heapClassInst.heapFloat[r11 + numDefine6];
                  f1 = f1 * f0;
                  f3 = f3 * f2;
                  f6 = heapClassInst.heapFloat[r10 + numDefine78];
                  f7 = heapClassInst.heapFloat[r11 + numDefine3];
                  f8 = heapClassInst.heapFloat[r11 + numDefine9];
                  f9 = heapClassInst.heapFloat[r11 + numDefine10];
                  f10 = heapClassInst.heapFloat[r11 + numDefine7];
                  f4 = f4 * f0;
                  f5 = f5 * f2;
                  f1 = f1 + f3;
                  f3 = f7 * f6;
                  f7 = heapClassInst.heapFloat[r11 + numDefine11];
                  f0 = f8 * f0;
                  f2 = f9 * f2;
                  f4 = f4 + f5;
                  f5 = f10 * f6;
                  f1 = f1 + f3;
                  f3 = heapClassInst.heapFloat[r11 + numDefine13];
                  f8 = heapClassInst.heapFloat[r11 + numDefine15];
                  f9 = heapClassInst.heapFloat[r11 + numDefine14];
                  f4 = f4 + f5;
                  f0 = f0 + f2;
                  f2 = f7 * f6;
                  f1 = f1 + f3;
                  f0 = f0 + f2;
                  f2 = f4 + f9;
                  heapClassInst.heapFloat[r9 + numDefine12] = f1;
                  f0 = f0 + f8;
                  heapClassInst.heapFloat[r9 + numDefine13] = f2;
                  heapClassInst.heapFloat[r9 + numDefine14] = f0;
                  heapClassInst.heap32[r9 + numDefine15] = 0;
                  if (!(r8 === 0)) {
                    r8 = heapClassInst.heap32[r1];
                    r8 = r8 >> numDefine2;
                    r8 = heapClassInst.heap32[r8 + numDefine4];
                    heapClassInst.heap32[g0] = r0;
                    functionTable[r8 >> numDefine2](i7);
                    r9 = commonVariable.rg0 >> numDefine2;
                    r9 = heapClassInst.heap32[r9];
                    r9 = r9 >> numDefine2;
                    r9 = heapClassInst.heap32[r9 + numDefine14];
                    heapClassInst.heap32[g0] = commonVariable.rg0;
                    heapClassInst.heap32[g0 + 1] = r2;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                    heapClassInst.heapFloat[g0 + numDefine2] = f0;
                    functionTable[r9 >> numDefine2](i7);
                  }
                } else {
                  if (r11 === numDefine4) {
                    r2 = heapClassInst.heap32[r10 + numDefine5];
                    r2 = r2 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r2 + 1];
                    f1 = heapClassInst.heapFloat[r10 + numDefine135];
                    f2 = heapClassInst.heapFloat[r2 + numDefine2];
                    f3 = heapClassInst.heapFloat[r10 + numDefine139];
                    f4 = heapClassInst.heapFloat[r10 + numDefine136];
                    f5 = heapClassInst.heapFloat[r10 + numDefine140];
                    f6 = f1 * f0;
                    f7 = f3 * f2;
                    f8 = heapClassInst.heapFloat[r2 + numDefine3];
                    f9 = heapClassInst.heapFloat[r10 + numDefine143];
                    f10 = heapClassInst.heapFloat[r2 + numDefine9];
                    f11 = heapClassInst.heapFloat[r10 + numDefine147];
                    f12 = heapClassInst.heapFloat[r2 + numDefine5];
                    f13 = heapClassInst.heapFloat[r10 + numDefine137];
                    f14 = heapClassInst.heapFloat[r2 + numDefine10];
                    f15 = heapClassInst.heapFloat[r10 + numDefine148];
                    f16 = heapClassInst.heapFloat[r2 + numDefine6];
                    f17 = heapClassInst.heapFloat[r10 + numDefine141];
                    f18 = heapClassInst.heapFloat[r2 + numDefine11];
                    f19 = heapClassInst.heapFloat[r10 + numDefine149];
                    f20 = heapClassInst.heapFloat[r2 + numDefine7];
                    f21 = heapClassInst.heapFloat[r10 + numDefine145];
                    f22 = heapClassInst.heapFloat[r10 + numDefine144];
                    f23 = f4 * f0;
                    f24 = f5 * f2;
                    f6 = f6 + f7;
                    f7 = f9 * f8;
                    f25 = heapClassInst.heapFloat[r2 + numDefine15];
                    f26 = heapClassInst.heapFloat[r2 + numDefine14];
                    f27 = heapClassInst.heapFloat[r2 + numDefine13];
                    f28 = f13 * f0;
                    f29 = f17 * f2;
                    f23 = f23 + f24;
                    f24 = f22 * f8;
                    f6 = f6 + f7;
                    r2 = r3 >> numDefine2;
                    f7 = f28 + f29;
                    f28 = f21 * f8;
                    f23 = f23 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg74] = f6;
                    f6 = f1 * f12;
                    f24 = f3 * f16;
                    f7 = f7 + f28;
                    heapClassInst.heapFloat[r2 + 1] = f23;
                    heapClassInst.heapFloat[r2 + numDefine2] = f7;
                    f7 = f4 * f12;
                    f23 = f5 * f16;
                    f6 = f6 + f24;
                    f24 = f9 * f20;
                    f28 = f13 * f12;
                    f29 = f17 * f16;
                    f7 = f7 + f23;
                    f23 = f22 * f20;
                    f6 = f6 + f24;
                    heapClassInst.heap32[r2 + numDefine3] = 0;
                    f24 = f28 + f29;
                    f28 = f21 * f20;
                    f7 = f7 + f23;
                    heapClassInst.heapFloat[r2 + numDefine4] = f6;
                    f1 = f1 * f10;
                    f3 = f3 * f14;
                    f6 = f24 + f28;
                    heapClassInst.heapFloat[r2 + numDefine5] = f7;
                    heapClassInst.heapFloat[r2 + numDefine6] = f6;
                    f4 = f4 * f10;
                    f5 = f5 * f14;
                    f1 = f1 + f3;
                    f3 = f9 * f18;
                    f6 = f13 * f10;
                    f7 = f17 * f14;
                    f4 = f4 + f5;
                    f5 = f22 * f18;
                    f1 = f1 + f3;
                    heapClassInst.heap32[r2 + numDefine7] = 0;
                    f0 = f0 * f11;
                    f2 = f2 * f15;
                    f3 = f6 + f7;
                    f6 = f21 * f18;
                    f4 = f4 + f5;
                    heapClassInst.heapFloat[r2 + numDefine8] = f1;
                    f1 = f12 * f11;
                    f5 = f16 * f15;
                    f0 = f0 + f2;
                    f2 = f8 * f19;
                    f3 = f3 + f6;
                    heapClassInst.heapFloat[r2 + numDefine9] = f4;
                    f0 = f0 + f2;
                    heapClassInst.heapFloat[r2 + numDefine10] = f3;
                    f2 = f10 * f11;
                    f3 = f14 * f15;
                    f1 = f1 + f5;
                    f4 = f20 * f19;
                    f1 = f1 + f4;
                    f2 = f2 + f3;
                    f3 = f18 * f19;
                    f0 = f0 + f27;
                    heapClassInst.heap32[r2 + numDefine11] = 0;
                    f2 = f2 + f3;
                    f1 = f1 + f26;
                    heapClassInst.heapFloat[r2 + numDefine12] = f0;
                    f0 = f2 + f25;
                    heapClassInst.heapFloat[r2 + numDefine13] = f1;
                    heapClassInst.heapFloat[r2 + numDefine14] = f0;
                    heapClassInst.heap32[r2 + numDefine15] = 0;
                    if (!(r8 === 0)) {
                      r11 = heapClassInst.heap32[r1];
                      r11 = r11 >> numDefine2;
                      r11 = heapClassInst.heap32[r11 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r11 >> numDefine2](i7);
                      r12 = commonVariable.rg0 >> numDefine2;
                      r12 = heapClassInst.heap32[r12];
                      r12 = r12 >> numDefine2;
                      r12 = heapClassInst.heap32[r12 + numDefine14];
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r3;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      heapClassInst.heapFloat[g0 + numDefine2] = f0;
                      functionTable[r12 >> numDefine2](i7);
                    }
                    r11 = heapClassInst.heap32[r10 + numDefine6];
                    r11 = r11 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r11 + 1];
                    f1 = heapClassInst.heapFloat[r10 + numDefine151];
                    f2 = heapClassInst.heapFloat[r11 + numDefine2];
                    f3 = heapClassInst.heapFloat[r10 + numDefine155];
                    f4 = heapClassInst.heapFloat[r10 + numDefine152];
                    f5 = heapClassInst.heapFloat[r10 + numDefine156];
                    f6 = f1 * f0;
                    f7 = f3 * f2;
                    f8 = heapClassInst.heapFloat[r11 + numDefine3];
                    f9 = heapClassInst.heapFloat[r10 + numDefine159];
                    f10 = heapClassInst.heapFloat[r11 + numDefine9];
                    f11 = heapClassInst.heapFloat[r10 + numDefine163];
                    f12 = heapClassInst.heapFloat[r11 + numDefine5];
                    f13 = heapClassInst.heapFloat[r10 + numDefine153];
                    f14 = heapClassInst.heapFloat[r11 + numDefine10];
                    f15 = heapClassInst.heapFloat[r10 + numDefine164];
                    f16 = heapClassInst.heapFloat[r11 + numDefine6];
                    f17 = heapClassInst.heapFloat[r10 + numDefine157];
                    f18 = heapClassInst.heapFloat[r11 + numDefine11];
                    f19 = heapClassInst.heapFloat[r10 + numDefine165];
                    f20 = heapClassInst.heapFloat[r11 + numDefine7];
                    f21 = heapClassInst.heapFloat[r10 + numDefine161];
                    f22 = heapClassInst.heapFloat[r10 + numDefine160];
                    f23 = f4 * f0;
                    f24 = f5 * f2;
                    f6 = f6 + f7;
                    f7 = f9 * f8;
                    f25 = heapClassInst.heapFloat[r11 + numDefine15];
                    f26 = heapClassInst.heapFloat[r11 + numDefine14];
                    f27 = heapClassInst.heapFloat[r11 + numDefine13];
                    f28 = f13 * f0;
                    f29 = f17 * f2;
                    f23 = f23 + f24;
                    f24 = f22 * f8;
                    f6 = f6 + f7;
                    f7 = f28 + f29;
                    f28 = f21 * f8;
                    f23 = f23 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg74] = f6;
                    f6 = f1 * f12;
                    f24 = f3 * f16;
                    f7 = f7 + f28;
                    heapClassInst.heapFloat[r2 + 1] = f23;
                    heapClassInst.heapFloat[r2 + numDefine2] = f7;
                    f7 = f4 * f12;
                    f23 = f5 * f16;
                    f6 = f6 + f24;
                    f24 = f9 * f20;
                    f28 = f13 * f12;
                    f29 = f17 * f16;
                    f7 = f7 + f23;
                    f23 = f22 * f20;
                    f6 = f6 + f24;
                    heapClassInst.heap32[r2 + numDefine3] = 0;
                    f24 = f28 + f29;
                    f28 = f21 * f20;
                    f7 = f7 + f23;
                    heapClassInst.heapFloat[r2 + numDefine4] = f6;
                    f1 = f1 * f10;
                    f3 = f3 * f14;
                    f6 = f24 + f28;
                    heapClassInst.heapFloat[r2 + numDefine5] = f7;
                    heapClassInst.heapFloat[r2 + numDefine6] = f6;
                    f4 = f4 * f10;
                    f5 = f5 * f14;
                    f1 = f1 + f3;
                    f3 = f9 * f18;
                    f6 = f13 * f10;
                    f7 = f17 * f14;
                    f4 = f4 + f5;
                    f5 = f22 * f18;
                    f1 = f1 + f3;
                    heapClassInst.heap32[r2 + numDefine7] = 0;
                    f0 = f0 * f11;
                    f2 = f2 * f15;
                    f3 = f6 + f7;
                    f6 = f21 * f18;
                    f4 = f4 + f5;
                    heapClassInst.heapFloat[r2 + numDefine8] = f1;
                    f1 = f12 * f11;
                    f5 = f16 * f15;
                    f0 = f0 + f2;
                    f2 = f8 * f19;
                    f3 = f3 + f6;
                    heapClassInst.heapFloat[r2 + numDefine9] = f4;
                    f0 = f0 + f2;
                    heapClassInst.heapFloat[r2 + numDefine10] = f3;
                    f2 = f10 * f11;
                    f3 = f14 * f15;
                    f1 = f1 + f5;
                    f4 = f20 * f19;
                    f1 = f1 + f4;
                    f2 = f2 + f3;
                    f3 = f18 * f19;
                    f0 = f0 + f27;
                    heapClassInst.heap32[r2 + numDefine11] = 0;
                    f2 = f2 + f3;
                    f1 = f1 + f26;
                    heapClassInst.heapFloat[r2 + numDefine12] = f0;
                    f0 = f2 + f25;
                    heapClassInst.heapFloat[r2 + numDefine13] = f1;
                    heapClassInst.heapFloat[r2 + numDefine14] = f0;
                    heapClassInst.heap32[r2 + numDefine15] = 0;
                    if (!(r8 === 0)) {
                      r8 = heapClassInst.heap32[r1];
                      r8 = r8 >> numDefine2;
                      r8 = heapClassInst.heap32[r8 + numDefine4];
                      heapClassInst.heap32[g0] = r0;
                      functionTable[r8 >> numDefine2](i7);
                      r11 = commonVariable.rg0 >> numDefine2;
                      r11 = heapClassInst.heap32[r11];
                      r11 = r11 >> numDefine2;
                      r11 = heapClassInst.heap32[r11 + numDefine14];
                      heapClassInst.heap32[g0] = commonVariable.rg0;
                      heapClassInst.heap32[g0 + 1] = r3;
                      f0 = heapClassInst.heapFloat[fp + numDefineNeg191];
                      heapClassInst.heapFloat[g0 + numDefine2] = f0;
                      functionTable[r11 >> numDefine2](i7);
                    }
                    f0 = heapClassInst.heapFloat[r10 + numDefine172];
                    f1 = heapClassInst.heapFloat[r10 + numDefine173];
                    if (!(f0 === f1)) {
                      if (!(r9 === 0)) {
                        r8 = sp + numDefineNeg312;
                        r9 = r8 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg78] = heapClassInst.heap32[r2 + numDefine2];
                        heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r2 + numDefine6];
                        heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r2 + numDefine10];
                        r10 = sp + numDefineNeg328;
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        r9 = r10 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg82] = heapClassInst.heap32[fp + numDefineNeg74];
                        heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r2 + numDefine4];
                        heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r2 + numDefine8];
                        heapClassInst.heap32[r9 + numDefine3] = 0;
                        r2 = heapClassInst.heap32[r1];
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2 + numDefine4];
                        heapClassInst.heap32[g0] = r0;
                        functionTable[r2 >> numDefine2](i7);
                        r9 = commonVariable.rg0 >> numDefine2;
                        r9 = heapClassInst.heap32[r9];
                        r9 = r9 >> numDefine2;
                        r9 = heapClassInst.heap32[r9 + numDefine15];
                        r11 = sp + numDefineNeg168;
                        r12 = r11 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg42] = 0;
                        heapClassInst.heap32[r12 + 1] = 0;
                        heapClassInst.heap32[r12 + numDefine2] = 0;
                        heapClassInst.heap32[r12 + numDefine3] = 0;
                        f2 = numDefineFloat265;

                        r12 = f0 <= f1 ? 1 : 0;
                        f3 = heapClassInst.heapFloat[fp + numDefineNeg192];
                        f3 = f0 > f1 ? f3 : f0;
                        f0 = f0 > f1 ? f2 : f1;
                        r12 = r12 & 1;
                        heapClassInst.heap32[g0] = commonVariable.rg0;
                        heapClassInst.heap32[g0 + 1] = r5;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r10;
                        f1 = heapClassInst.heapFloat[fp + numDefineNeg191];
                        heapClassInst.heapFloat[g0 + numDefine4] = f1;
                        heapClassInst.heapFloat[g0 + numDefine5] = f1;
                        heapClassInst.heapFloat[g0 + numDefine6] = f3;
                        heapClassInst.heapFloat[g0 + numDefine7] = f0;
                        heapClassInst.heap32[g0 + numDefine8] = r11;
                        heapClassInst.heap32[g0 + numDefine9] = r12;
                        heapClassInst.heap32[g0 + numDefine10] = numDefine16192;
                        functionTable[r9 >> numDefine2](i7);
                      }
                    }
                  }
                }
              }
            }
          } while (false);
          r2 = (r7 + -1) | 0;
          if (r7 !== 0) {
            continue repeat5;
          } else {
            break repeat5;
          }
        }
      }
    }
  }
  r2 = heapClassInst.heap32[r1];
  r2 = r2 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r2 >> numDefine2](i7);
  r2 = commonVariable.rg0;
  repeat74: do {
    if (!(r2 === 0)) {
      r2 = heapClassInst.heap32[r1];
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2 + numDefine4];
      heapClassInst.heap32[g0] = r0;
      functionTable[r2 >> numDefine2](i7);
      r3 = commonVariable.rg0 >> numDefine2;
      r3 = heapClassInst.heap32[r3];
      r3 = r3 >> numDefine2;
      r3 = heapClassInst.heap32[r3 + numDefine12];
      heapClassInst.heap32[g0] = commonVariable.rg0;
      functionTable[r3 >> numDefine2](i7);
      r2 = commonVariable.rg0 & numDefine3;
      if (!(r2 === 0)) {
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable[r2 >> numDefine2](i7);
        r2 = commonVariable.rg0;
        if (!(r2 === 0)) {
          r2 = heapClassInst.heap32[r1];
          r2 = r2 >> numDefine2;
          r2 = heapClassInst.heap32[r2 + numDefine4];
          heapClassInst.heap32[g0] = r0;
          functionTable[r2 >> numDefine2](i7);
          r2 = commonVariable.rg0 >> numDefine2;
          r2 = heapClassInst.heap32[r2];
          r2 = r2 >> numDefine2;
          r2 = heapClassInst.heap32[r2 + numDefine12];
          heapClassInst.heap32[g0] = commonVariable.rg0;
          functionTable[r2 >> numDefine2](i7);
          r0 = commonVariable.rg0;
          if (!(r0 === 0)) {
            r0 = heapClassInst.heap32[r1 + numDefine63];
            if (!(r0 < 1)) {
              r0 = 0;
              repeat80: while (true) {
                r2 = heapClassInst.heap32[r1 + numDefine65];
                r3 = r0 << numDefine2;
                r2 = (r2 + r3) | 0;
                r2 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r3];
                r3 = r3 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine3];
                r4 = heapClassInst.heap32[r1 + numDefine21];
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r4;
                r0 = (r0 + 1) | 0;
                functionTable[r3 >> numDefine2](i7);
                r2 = heapClassInst.heap32[r1 + numDefine63];
                if (r2 > r0) {
                  continue repeat80;
                } else {
                  break repeat74;
                }
              }
            }
          }
        }
      }
    }
  } while (false);
  r0 = zn15CProfileManager11CurrentNodeE;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  r2 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[r2 + numDefine4];
  r3 = (r3 + -1) | 0;
  heapClassInst.heap32[r2 + numDefine4] = r3;
  repeat83: do {
    if (!(r3 !== 0)) {
      r3 = heapClassInst.heap32[r2 + 1];
      if (r3 !== 0) {
        r1 = sp + numDefineNeg8;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = 0;
        r3 = zl13gProfileClock2E0;
        getTimeOfDay(i7);
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r1 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + numDefineNeg2];
        r5 = heapClassInst.heap32[r3];
        r4 = (r4 - r5) | 0;
        r1 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[r3 + 1];
        r1 = (r1 - r3) | 0;
        r3 = (r4 * numDefineN6) | 0;
        r1 = (r1 + r3) | 0;
        r3 = heapClassInst.heap32[r2 + numDefine3];
        r1 = (r1 - r3) | 0;
        f0 = uint(r1);
        f1 = numDefine1000;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f0 / f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r2 + numDefine2] = f0;
        r1 = heapClassInst.heap32[r2 + numDefine4];
        if (r1 !== 0) {
          break repeat83;
        } else {
          r1 = heapClassInst.heap32[r0];
        }
      }
      r1 = r1 >> numDefine2;
      r1 = heapClassInst.heap32[r1 + numDefine5];
      heapClassInst.heap32[r0] = r1;
    }
  } while (false);
  return;
}

function zn23btDiscreteDynamicsWorld18saveKinematicStateEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg40;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine2];
  if (!(r1 < 1)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    f1 = 1;
    f1 = f1 / f0;
    r1 = 0;
    repeat3: while (true) {
      r2 = heapClassInst.heap32[r0 + numDefine4];
      r3 = r1 << numDefine2;
      r2 = (r2 + r3) | 0;
      r2 = r2 >> numDefine2;
      r2 = heapClassInst.heap32[r2];
      r3 = heapClassInst.heapU8[r2 + numDefine232];
      r3 = r3 & numDefine2;
      if (!(r3 === 0)) {
        if (!(r2 === 0)) {
          r3 = r2 >> numDefine2;
          r4 = heapClassInst.heap32[r3 + numDefine54];
          if (!(r4 === numDefine2)) {
            r4 = heapClassInst.heapU8[r2 + numDefine204];
            r4 = r4 & numDefine2;
            if (!(r4 === 0)) {
              f2 = 0;
              if (!(f0 === f2)) {
                r4 = heapClassInst.heap32[r3 + numDefine118];
                if (!(r4 === 0)) {
                  r5 = r4 >> numDefine2;
                  r5 = heapClassInst.heap32[r5];
                  r5 = r5 >> numDefine2;
                  r5 = heapClassInst.heap32[r5 + numDefine2];
                  r6 = (r2 + numDefine4) | 0;
                  heapClassInst.heap32[g0] = r4;
                  heapClassInst.heap32[g0 + 1] = r6;
                  functionTable[r5 >> numDefine2](i7);
                }
                f2 = heapClassInst.heapFloat[r3 + numDefine13];
                f3 = heapClassInst.heapFloat[r3 + numDefine29];
                f2 = f2 - f3;
                f3 = heapClassInst.heapFloat[r3 + numDefine15];
                f4 = heapClassInst.heapFloat[r3 + numDefine31];
                f5 = heapClassInst.heapFloat[r3 + numDefine14];
                f6 = heapClassInst.heapFloat[r3 + numDefine30];
                f5 = f5 - f6;
                f2 = f2 * f1;
                f3 = f3 - f4;
                f4 = f5 * f1;
                heapClassInst.heapFloat[r3 + numDefine76] = f2;
                f2 = f3 * f1;
                heapClassInst.heapFloat[r3 + numDefine77] = f4;
                heapClassInst.heapFloat[r3 + numDefine78] = f2;
                heapClassInst.heap32[r3 + numDefine79] = 0;
                r4 = sp + numDefineNeg16;
                r5 = (r2 + numDefine68) | 0;
                r2 = (r2 + numDefine4) | 0;
                r6 = sp + numDefineNeg20;
                heapClassInst.heap32[g0] = r5;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = r4;
                heapClassInst.heap32[g0 + numDefine3] = r6;
                zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
                r2 = r4 >> numDefine2;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg5];
                f3 = heapClassInst.heapFloat[fp + numDefineNeg4];
                f3 = f3 * f2;
                f4 = heapClassInst.heapFloat[r2 + numDefine2];
                f5 = heapClassInst.heapFloat[r2 + 1];
                f5 = f5 * f2;
                f3 = f3 * f1;
                f2 = f4 * f2;
                f4 = f5 * f1;
                heapClassInst.heapFloat[r3 + numDefine80] = f3;
                f2 = f2 * f1;
                heapClassInst.heapFloat[r3 + numDefine81] = f4;
                heapClassInst.heapFloat[r3 + numDefine82] = f2;
                heapClassInst.heap32[r3 + numDefine83] = 0;
                heapClassInst.heap32[r3 + numDefine33] = heapClassInst.heap32[r3 + numDefine76];
                heapClassInst.heap32[r3 + numDefine34] = heapClassInst.heap32[r3 + numDefine77];
                heapClassInst.heap32[r3 + numDefine35] = heapClassInst.heap32[r3 + numDefine78];
                heapClassInst.heap32[r3 + numDefine36] = heapClassInst.heap32[r3 + numDefine79];
                heapClassInst.heapFloat[r3 + numDefine37] = f3;
                heapClassInst.heapFloat[r3 + numDefine38] = f4;
                heapClassInst.heapFloat[r3 + numDefine39] = f2;
                heapClassInst.heap32[r3 + numDefine40] = 0;
                heapClassInst.heap32[r3 + numDefine17] = heapClassInst.heap32[r3 + 1];
                heapClassInst.heap32[r3 + numDefine18] = heapClassInst.heap32[r3 + numDefine2];
                heapClassInst.heap32[r3 + numDefine19] = heapClassInst.heap32[r3 + numDefine3];
                heapClassInst.heap32[r3 + numDefine20] = heapClassInst.heap32[r3 + numDefine4];
                heapClassInst.heap32[r3 + numDefine21] = heapClassInst.heap32[r3 + numDefine5];
                heapClassInst.heap32[r3 + numDefine22] = heapClassInst.heap32[r3 + numDefine6];
                heapClassInst.heap32[r3 + numDefine23] = heapClassInst.heap32[r3 + numDefine7];
                heapClassInst.heap32[r3 + numDefine24] = heapClassInst.heap32[r3 + numDefine8];
                heapClassInst.heap32[r3 + numDefine25] = heapClassInst.heap32[r3 + numDefine9];
                heapClassInst.heap32[r3 + numDefine26] = heapClassInst.heap32[r3 + numDefine10];
                heapClassInst.heap32[r3 + numDefine27] = heapClassInst.heap32[r3 + numDefine11];
                heapClassInst.heap32[r3 + numDefine28] = heapClassInst.heap32[r3 + numDefine12];
                heapClassInst.heap32[r3 + numDefine29] = heapClassInst.heap32[r3 + numDefine13];
                heapClassInst.heap32[r3 + numDefine30] = heapClassInst.heap32[r3 + numDefine14];
                heapClassInst.heap32[r3 + numDefine31] = heapClassInst.heap32[r3 + numDefine15];
                heapClassInst.heap32[r3 + numDefine32] = heapClassInst.heap32[r3 + numDefine16];
              }
            }
          }
        }
      }
      r1 = (r1 + 1) | 0;
      r2 = heapClassInst.heap32[r0 + numDefine2];
      if (r2 > r1) {
        continue repeat3;
      } else {
        break repeat3;
      }
    }
  }
  return;
}

function zn15btDynamicsWorldD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv15btDynamicsWorld;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn16btCollisionWorldD2Ev(i7);
  return;
}

function zn15btDynamicsWorldD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv15btDynamicsWorld;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn16btCollisionWorldD2Ev(i7);
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn23btDiscreteDynamicsWorldD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv23btDiscreteDynamicsWorld;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine244];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine45];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r2 + numDefine45];
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heapU8[r0 + numDefine245];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine44];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r2 + numDefine44];
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heap32[r2 + numDefine65];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine264];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine65] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine264] = r1;
  heapClassInst.heap32[r2 + numDefine65] = 0;
  heapClassInst.heap32[r2 + numDefine63] = 0;
  heapClassInst.heap32[r2 + numDefine64] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine54];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine220];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine54] = 0;
  }
  heapClassInst.heap8[r0 + numDefine220] = r1;
  heapClassInst.heap32[r2 + numDefine54] = 0;
  heapClassInst.heap32[r2 + numDefine52] = 0;
  heapClassInst.heap32[r2 + numDefine53] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine49];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine200];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine49] = 0;
  }
  heapClassInst.heap8[r0 + numDefine200] = r1;
  heapClassInst.heap32[r2 + numDefine49] = 0;
  r1 = ztv15btDynamicsWorld;
  heapClassInst.heap32[r2 + numDefine47] = 0;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine48] = 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn16btCollisionWorldD2Ev(i7);
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn23btDiscreteDynamicsWorldD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  heapClassInst.heap32[g0] = r0;
  zn23btDiscreteDynamicsWorldD2Ev(i7);
  return;
}

function zn23btDiscreteDynamicsWorldD2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv23btDiscreteDynamicsWorld;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heapU8[r0 + numDefine244];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine45];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r2 + numDefine45];
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heapU8[r0 + numDefine245];
  if (!(r1 === 0)) {
    r1 = heapClassInst.heap32[r2 + numDefine44];
    r3 = r1 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    r3 = r3 >> numDefine2;
    r3 = heapClassInst.heap32[r3];
    heapClassInst.heap32[g0] = r1;
    functionTable[r3 >> numDefine2](i7);
    r1 = heapClassInst.heap32[r2 + numDefine44];
    if (!(r1 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
  }
  r1 = heapClassInst.heap32[r2 + numDefine65];
  if (!(r1 === 0)) {
    r3 = heapClassInst.heapU8[r0 + numDefine264];
    if (!(r3 === 0)) {
      r3 = gNumAlignedFree;
      r3 = r3 >> numDefine2;
      r4 = heapClassInst.heap32[r3];
      r4 = (r4 + 1) | 0;
      r1 = r1 >> numDefine2;
      heapClassInst.heap32[r3] = r4;
      r1 = heapClassInst.heap32[r1 + -1];
      heapClassInst.heap32[g0] = r1;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine65] = 0;
  }
  r1 = 1;
  heapClassInst.heap8[r0 + numDefine264] = r1;
  heapClassInst.heap32[r2 + numDefine65] = 0;
  heapClassInst.heap32[r2 + numDefine63] = 0;
  heapClassInst.heap32[r2 + numDefine64] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine54];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine220];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine54] = 0;
  }
  heapClassInst.heap8[r0 + numDefine220] = r1;
  heapClassInst.heap32[r2 + numDefine54] = 0;
  heapClassInst.heap32[r2 + numDefine52] = 0;
  heapClassInst.heap32[r2 + numDefine53] = 0;
  r3 = heapClassInst.heap32[r2 + numDefine49];
  if (!(r3 === 0)) {
    r4 = heapClassInst.heapU8[r0 + numDefine200];
    if (!(r4 === 0)) {
      r4 = gNumAlignedFree;
      r4 = r4 >> numDefine2;
      r5 = heapClassInst.heap32[r4];
      r5 = (r5 + 1) | 0;
      r3 = r3 >> numDefine2;
      heapClassInst.heap32[r4] = r5;
      r3 = heapClassInst.heap32[r3 + -1];
      heapClassInst.heap32[g0] = r3;
      free(i7);
    }
    heapClassInst.heap32[r2 + numDefine49] = 0;
  }
  heapClassInst.heap8[r0 + numDefine200] = r1;
  heapClassInst.heap32[r2 + numDefine49] = 0;
  r1 = ztv15btDynamicsWorld;
  heapClassInst.heap32[r2 + numDefine47] = 0;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2 + numDefine48] = 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[g0] = r0;
  zn16btCollisionWorldD2Ev(i7);
  return;
}

function zn11btRigidBody18proceedToTransformERK11btTransform(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let r11: number = 0;
  let r12: number = 0;
  let r13: number = 0;
  let r14: number = 0;
  let r15: number = 0;
  let r16: number = 0;
  let r17: number = 0;
  let r18: number = 0;
  let r19: number = 0;
  let r20: number = 0;
  let r21: number = 0;
  let r22: number = 0;
  let r23: number = 0;
  let r24: number = 0;
  let r25: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg48;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heapU8[r0 + numDefine204];
  r2 = r2 & numDefine3;
  if (r2 === 0) {
    r2 = r0 >> numDefine2;
    r24 = r1 >> numDefine2;
    heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r24];
    heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r24 + 1];
    heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r24 + numDefine2];
    heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r24 + numDefine3];
    heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r24 + numDefine4];
    heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r24 + numDefine5];
    heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r24 + numDefine6];
    heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r24 + numDefine7];
    heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r24 + numDefine8];
    heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r24 + numDefine9];
    heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r24 + numDefine10];
    heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r24 + numDefine11];
    heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r24 + numDefine12];
    heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r24 + numDefine13];
    r15 = (r1 + numDefine4) | 0;
    r16 = (r1 + numDefine8) | 0;
    r17 = (r1 + numDefine12) | 0;
    r18 = (r1 + numDefine16) | 0;
    r19 = (r1 + numDefine20) | 0;
    r20 = (r1 + numDefine24) | 0;
    r21 = (r1 + numDefine28) | 0;
    r22 = (r1 + numDefine32) | 0;
    r23 = (r1 + numDefine36) | 0;
    r3 = (r1 + numDefine40) | 0;
    heapClassInst.heap32[fp + numDefineNeg10] = r3;
    r3 = (r1 + numDefine44) | 0;
    heapClassInst.heap32[fp + numDefineNeg4] = r3;
    r3 = (r1 + numDefine48) | 0;
    heapClassInst.heap32[fp + numDefineNeg7] = r3;
    r3 = (r1 + numDefine52) | 0;
    heapClassInst.heap32[fp + numDefineNeg6] = r3;
    r3 = (r1 + numDefine56) | 0;
    heapClassInst.heap32[fp + numDefineNeg9] = r3;
    r3 = (r1 + numDefine60) | 0;
    heapClassInst.heap32[fp + numDefineNeg8] = r3;
    r3 = (r0 + numDefine4) | 0;
    r4 = (r0 + numDefine8) | 0;
    r5 = (r0 + numDefine12) | 0;
    r6 = (r0 + numDefine16) | 0;
    r7 = (r0 + numDefine20) | 0;
    r8 = (r0 + numDefine24) | 0;
    r9 = (r0 + numDefine28) | 0;
    r10 = (r0 + numDefine32) | 0;
    r11 = (r0 + numDefine36) | 0;
    r12 = (r0 + numDefine40) | 0;
    r13 = (r0 + numDefine44) | 0;
    r14 = (r0 + numDefine48) | 0;
    r25 = (r0 + numDefine52) | 0;
    heapClassInst.heap32[fp + numDefineNeg5] = r25;
    r25 = (r0 + numDefine56) | 0;
    heapClassInst.heap32[fp + numDefineNeg3] = r25;
    r25 = (r0 + numDefine60) | 0;
    heapClassInst.heap32[fp + numDefineNeg2] = r25;
    r25 = (r0 + numDefine64) | 0;
    heapClassInst.heap32[fp + -1] = r25;
    heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r24 + numDefine14];
    heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r24 + numDefine15];
  } else {
    r2 = r0 >> numDefine2;
    heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r2 + 1];
    heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r2 + numDefine2];
    heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r2 + numDefine4];
    heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r2 + numDefine5];
    heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r2 + numDefine6];
    heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r2 + numDefine7];
    heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r2 + numDefine8];
    heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r2 + numDefine9];
    heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r2 + numDefine10];
    heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r2 + numDefine11];
    heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r2 + numDefine12];
    heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r2 + numDefine13];
    heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r2 + numDefine14];
    r3 = (r0 + numDefine4) | 0;
    r4 = (r0 + numDefine8) | 0;
    r5 = (r0 + numDefine12) | 0;
    r6 = (r0 + numDefine16) | 0;
    r7 = (r0 + numDefine20) | 0;
    r8 = (r0 + numDefine24) | 0;
    r9 = (r0 + numDefine28) | 0;
    r10 = (r0 + numDefine32) | 0;
    r11 = (r0 + numDefine36) | 0;
    r12 = (r0 + numDefine40) | 0;
    r13 = (r0 + numDefine44) | 0;
    r14 = (r0 + numDefine48) | 0;
    r15 = (r0 + numDefine52) | 0;
    heapClassInst.heap32[fp + numDefineNeg5] = r15;
    r15 = (r0 + numDefine56) | 0;
    heapClassInst.heap32[fp + numDefineNeg3] = r15;
    r15 = (r0 + numDefine60) | 0;
    heapClassInst.heap32[fp + numDefineNeg2] = r15;
    r15 = (r0 + numDefine64) | 0;
    heapClassInst.heap32[fp + -1] = r15;
    r15 = (r1 + numDefine4) | 0;
    r16 = (r1 + numDefine8) | 0;
    r17 = (r1 + numDefine12) | 0;
    r18 = (r1 + numDefine16) | 0;
    r19 = (r1 + numDefine20) | 0;
    r20 = (r1 + numDefine24) | 0;
    r21 = (r1 + numDefine28) | 0;
    r22 = (r1 + numDefine32) | 0;
    r23 = (r1 + numDefine36) | 0;
    r24 = (r1 + numDefine40) | 0;
    heapClassInst.heap32[fp + numDefineNeg10] = r24;
    r24 = (r1 + numDefine44) | 0;
    heapClassInst.heap32[fp + numDefineNeg4] = r24;
    r24 = (r1 + numDefine48) | 0;
    heapClassInst.heap32[fp + numDefineNeg7] = r24;
    r24 = (r1 + numDefine52) | 0;
    heapClassInst.heap32[fp + numDefineNeg6] = r24;
    r24 = (r1 + numDefine56) | 0;
    heapClassInst.heap32[fp + numDefineNeg9] = r24;
    r24 = (r1 + numDefine60) | 0;
    heapClassInst.heap32[fp + numDefineNeg8] = r24;
    heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r2 + numDefine15];
    heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r2 + numDefine16];
  }
  r2 = r0 >> numDefine2;
  heapClassInst.heap32[r2 + numDefine33] = heapClassInst.heap32[r2 + numDefine76];
  heapClassInst.heap32[r2 + numDefine34] = heapClassInst.heap32[r2 + numDefine77];
  heapClassInst.heap32[r2 + numDefine35] = heapClassInst.heap32[r2 + numDefine78];
  heapClassInst.heap32[r2 + numDefine36] = heapClassInst.heap32[r2 + numDefine79];
  heapClassInst.heap32[r2 + numDefine37] = heapClassInst.heap32[r2 + numDefine80];
  heapClassInst.heap32[r2 + numDefine38] = heapClassInst.heap32[r2 + numDefine81];
  heapClassInst.heap32[r2 + numDefine39] = heapClassInst.heap32[r2 + numDefine82];
  r3 = r3 >> numDefine2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r2 + numDefine40] = heapClassInst.heap32[r2 + numDefine83];
  r2 = r4 >> numDefine2;
  r4 = r15 >> numDefine2;
  heapClassInst.heap32[r3] = heapClassInst.heap32[r1];
  r1 = r5 >> numDefine2;
  r3 = r16 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = r6 >> numDefine2;
  r4 = r17 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = r7 >> numDefine2;
  r3 = r18 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = r8 >> numDefine2;
  r4 = r19 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = r9 >> numDefine2;
  r3 = r20 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = r10 >> numDefine2;
  r4 = r21 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = r11 >> numDefine2;
  r3 = r22 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = r12 >> numDefine2;
  r4 = r23 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = r13 >> numDefine2;
  r3 = heapClassInst.heap32[fp + numDefineNeg10];
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = r14 >> numDefine2;
  r4 = heapClassInst.heap32[fp + numDefineNeg4];
  r4 = r4 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = heapClassInst.heap32[fp + numDefineNeg5];
  r1 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[fp + numDefineNeg7];
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = heapClassInst.heap32[fp + numDefineNeg3];
  r2 = r2 >> numDefine2;
  r4 = heapClassInst.heap32[fp + numDefineNeg6];
  r4 = r4 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  r1 = heapClassInst.heap32[fp + numDefineNeg2];
  r1 = r1 >> numDefine2;
  r3 = heapClassInst.heap32[fp + numDefineNeg9];
  r3 = r3 >> numDefine2;
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  r2 = heapClassInst.heap32[fp + -1];
  r2 = r2 >> numDefine2;
  r4 = heapClassInst.heap32[fp + numDefineNeg8];
  r4 = r4 >> numDefine2;
  heapClassInst.heap32[r1] = heapClassInst.heap32[r3];
  heapClassInst.heap32[r2] = heapClassInst.heap32[r4];
  heapClassInst.heap32[g0] = r0;
  zn11btRigidBody19updateInertiaTensorEv(i7);
  return;
}

function znk11btRigidBody28calculateSerializeBufferSizeEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = numDefine480;
  commonVariable.rg0 = r0;
  return;
}

function znk11btRigidBody21serializeSingleObjectEP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = r0 >> numDefine2;
  r3 = r1 >> numDefine2;
  r4 = heapClassInst.heap32[r3];
  r5 = heapClassInst.heap32[r2];
  r4 = r4 >> numDefine2;
  r5 = r5 >> numDefine2;
  r4 = heapClassInst.heap32[r4 + numDefine4];
  r5 = heapClassInst.heap32[r5 + numDefine4];
  heapClassInst.heap32[g0] = r0;
  functionTable[r5 >> numDefine2](i7);
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = commonVariable.rg0;
  heapClassInst.heap32[g0 + numDefine2] = 1;
  functionTable[r4 >> numDefine2](i7);
  r4 = commonVariable.rg0;
  r2 = heapClassInst.heap32[r2];
  r2 = r2 >> numDefine2;
  r5 = r4 >> numDefine2;
  r2 = heapClassInst.heap32[r2 + numDefine5];
  r5 = heapClassInst.heap32[r5 + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r5;
  heapClassInst.heap32[g0 + numDefine2] = r1;
  functionTable[r2 >> numDefine2](i7);
  r3 = heapClassInst.heap32[r3];
  r3 = r3 >> numDefine2;
  r3 = heapClassInst.heap32[r3 + numDefine5];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = r4;
  heapClassInst.heap32[g0 + numDefine2] = commonVariable.rg0;
  heapClassInst.heap32[g0 + numDefine3] = numDefine45650;
  heapClassInst.heap32[g0 + numDefine4] = r0;
  functionTable[r3 >> numDefine2](i7);
  return;
}

function zn11btRigidBody24checkCollideWithOverrideEP17btCollisionObject(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let label = 0;
  i7 = sp + 0;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp + 1];
  r1 = heapClassInst.heapU8[r0 + numDefine232];
  r1 = r1 & numDefine2;
  repeat1: do {
    if (r1 !== 0) {
      if (r0 === 0) {
        label = 1;
      } else {
        r1 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine120];
        r3 = 0;
        repeat4: while (true) {
          if (r2 > r3) {
            r4 = heapClassInst.heap32[r1 + numDefine122];
            r5 = r3 << numDefine2;
            r4 = (r4 + r5) | 0;
            r4 = r4 >> numDefine2;
            r4 = heapClassInst.heap32[r4];
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine5];
            if (r5 !== r0) {
              r4 = heapClassInst.heap32[r4 + numDefine6];
              if (r4 === r0) {
                break repeat4;
              } else {
                r3 = (r3 + 1) | 0;
              }
            } else {
              break repeat4;
            }
          } else {
            label = 1;
            break repeat1;
          }
        }
        r0 = 0;
        label = numDefine9;
      }
    } else {
      label = 1;
    }
  } while (false);
  if (label === 1) {
    r0 = 1;
  }
  r0 = r0 & numDefine255;
  commonVariable.rg0 = r0;
  return;
}

function zn11btRigidBodyD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv11btRigidBody;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine120];
  if (r1 === 0) {
    r1 = heapClassInst.heap32[r2 + numDefine122];
    if (!(r1 === 0)) {
      r3 = heapClassInst.heapU8[r0 + numDefine492];
      if (!(r3 === 0)) {
        r3 = gNumAlignedFree;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        r4 = (r4 + 1) | 0;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r3] = r4;
        r1 = heapClassInst.heap32[r1 + -1];
        heapClassInst.heap32[g0] = r1;
        free(i7);
      }
      heapClassInst.heap32[r2 + numDefine122] = 0;
    }
    r1 = 1;
    heapClassInst.heap8[r0 + numDefine492] = r1;
    heapClassInst.heap32[r2 + numDefine122] = 0;
    r1 = ztv17btCollisionObject;
    heapClassInst.heap32[r2 + numDefine120] = 0;
    r1 = (r1 + numDefine8) | 0;
    heapClassInst.heap32[r2 + numDefine121] = 0;
    heapClassInst.heap32[r2] = r1;
    if (!(r0 === 0)) {
      r0 = gNumAlignedFree;
      r0 = r0 >> numDefine2;
      r1 = heapClassInst.heap32[r0];
      r1 = (r1 + 1) | 0;
      heapClassInst.heap32[r0] = r1;
      r0 = heapClassInst.heap32[r2 + -1];
      heapClassInst.heap32[g0] = r0;
      free(i7);
    }
    return;
  } else {
    r0 = twoEStr248;
    r2 = twoEStr34955;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = numDefine175;
    assertNew(i7);
  }
}

function zn11btRigidBodyD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztv11btRigidBody;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine120];
  if (r1 === 0) {
    r1 = heapClassInst.heap32[r2 + numDefine122];
    if (!(r1 === 0)) {
      r3 = heapClassInst.heapU8[r0 + numDefine492];
      if (!(r3 === 0)) {
        r3 = gNumAlignedFree;
        r3 = r3 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        r4 = (r4 + 1) | 0;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r3] = r4;
        r1 = heapClassInst.heap32[r1 + -1];
        heapClassInst.heap32[g0] = r1;
        free(i7);
      }
      heapClassInst.heap32[r2 + numDefine122] = 0;
    }
    r1 = 1;
    heapClassInst.heap8[r0 + numDefine492] = r1;
    heapClassInst.heap32[r2 + numDefine122] = 0;
    r0 = ztv17btCollisionObject;
    heapClassInst.heap32[r2 + numDefine120] = 0;
    r0 = (r0 + numDefine8) | 0;
    heapClassInst.heap32[r2 + numDefine121] = 0;
    heapClassInst.heap32[r2] = r0;
    return;
  } else {
    r0 = twoEStr248;
    r2 = twoEStr34955;
    heapClassInst.heap32[g0] = r0;
    heapClassInst.heap32[g0 + 1] = r2;
    heapClassInst.heap32[g0 + numDefine2] = numDefine175;
    assertNew(i7);
  }
}

function znk11btRigidBody9serializeEPvP12btSerializer(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg16;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heap32[fp + 1];
  r2 = heapClassInst.heap32[fp + numDefine2];
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = r1;
  heapClassInst.heap32[g0 + numDefine2] = r2;
  r1 = r1 >> numDefine2;
  r2 = r0 >> numDefine2;
  znk17btCollisionObject9serializeEPvP12btSerializer(i7);
  heapClassInst.heap32[r1 + numDefine62] = heapClassInst.heap32[r2 + numDefine64];
  heapClassInst.heap32[r1 + numDefine63] = heapClassInst.heap32[r2 + numDefine65];
  heapClassInst.heap32[r1 + numDefine64] = heapClassInst.heap32[r2 + numDefine66];
  heapClassInst.heap32[r1 + numDefine65] = heapClassInst.heap32[r2 + numDefine67];
  heapClassInst.heap32[r1 + numDefine66] = heapClassInst.heap32[r2 + numDefine68];
  heapClassInst.heap32[r1 + numDefine67] = heapClassInst.heap32[r2 + numDefine69];
  heapClassInst.heap32[r1 + numDefine68] = heapClassInst.heap32[r2 + numDefine70];
  heapClassInst.heap32[r1 + numDefine69] = heapClassInst.heap32[r2 + numDefine71];
  heapClassInst.heap32[r1 + numDefine70] = heapClassInst.heap32[r2 + numDefine72];
  heapClassInst.heap32[r1 + numDefine71] = heapClassInst.heap32[r2 + numDefine73];
  heapClassInst.heap32[r1 + numDefine72] = heapClassInst.heap32[r2 + numDefine74];
  heapClassInst.heap32[r1 + numDefine73] = heapClassInst.heap32[r2 + numDefine75];
  heapClassInst.heap32[r1 + numDefine74] = heapClassInst.heap32[r2 + numDefine76];
  heapClassInst.heap32[r1 + numDefine75] = heapClassInst.heap32[r2 + numDefine77];
  heapClassInst.heap32[r1 + numDefine76] = heapClassInst.heap32[r2 + numDefine78];
  heapClassInst.heap32[r1 + numDefine77] = heapClassInst.heap32[r2 + numDefine79];
  heapClassInst.heap32[r1 + numDefine78] = heapClassInst.heap32[r2 + numDefine80];
  heapClassInst.heap32[r1 + numDefine79] = heapClassInst.heap32[r2 + numDefine81];
  heapClassInst.heap32[r1 + numDefine80] = heapClassInst.heap32[r2 + numDefine82];
  heapClassInst.heap32[r1 + numDefine81] = heapClassInst.heap32[r2 + numDefine83];
  heapClassInst.heap32[r1 + numDefine110] = heapClassInst.heap32[r2 + numDefine84];
  heapClassInst.heap32[r1 + numDefine82] = heapClassInst.heap32[r2 + numDefine134];
  heapClassInst.heap32[r1 + numDefine83] = heapClassInst.heap32[r2 + numDefine135];
  heapClassInst.heap32[r1 + numDefine84] = heapClassInst.heap32[r2 + numDefine136];
  heapClassInst.heap32[r1 + numDefine85] = heapClassInst.heap32[r2 + numDefine137];
  heapClassInst.heap32[r1 + numDefine86] = heapClassInst.heap32[r2 + numDefine85];
  heapClassInst.heap32[r1 + numDefine87] = heapClassInst.heap32[r2 + numDefine86];
  heapClassInst.heap32[r1 + numDefine88] = heapClassInst.heap32[r2 + numDefine87];
  heapClassInst.heap32[r1 + numDefine89] = heapClassInst.heap32[r2 + numDefine88];
  heapClassInst.heap32[r1 + numDefine90] = heapClassInst.heap32[r2 + numDefine89];
  heapClassInst.heap32[r1 + numDefine91] = heapClassInst.heap32[r2 + numDefine90];
  heapClassInst.heap32[r1 + numDefine92] = heapClassInst.heap32[r2 + numDefine91];
  heapClassInst.heap32[r1 + numDefine93] = heapClassInst.heap32[r2 + numDefine92];
  heapClassInst.heap32[r1 + numDefine94] = heapClassInst.heap32[r2 + numDefine93];
  heapClassInst.heap32[r1 + numDefine95] = heapClassInst.heap32[r2 + numDefine94];
  heapClassInst.heap32[r1 + numDefine96] = heapClassInst.heap32[r2 + numDefine95];
  heapClassInst.heap32[r1 + numDefine97] = heapClassInst.heap32[r2 + numDefine96];
  heapClassInst.heap32[r1 + numDefine98] = heapClassInst.heap32[r2 + numDefine97];
  heapClassInst.heap32[r1 + numDefine99] = heapClassInst.heap32[r2 + numDefine98];
  heapClassInst.heap32[r1 + numDefine100] = heapClassInst.heap32[r2 + numDefine99];
  heapClassInst.heap32[r1 + numDefine101] = heapClassInst.heap32[r2 + numDefine100];
  heapClassInst.heap32[r1 + numDefine102] = heapClassInst.heap32[r2 + numDefine101];
  heapClassInst.heap32[r1 + numDefine103] = heapClassInst.heap32[r2 + numDefine102];
  heapClassInst.heap32[r1 + numDefine104] = heapClassInst.heap32[r2 + numDefine103];
  heapClassInst.heap32[r1 + numDefine105] = heapClassInst.heap32[r2 + numDefine104];
  heapClassInst.heap32[r1 + numDefine106] = heapClassInst.heap32[r2 + numDefine105];
  heapClassInst.heap32[r1 + numDefine107] = heapClassInst.heap32[r2 + numDefine106];
  heapClassInst.heap32[r1 + numDefine108] = heapClassInst.heap32[r2 + numDefine107];
  heapClassInst.heap32[r1 + numDefine109] = heapClassInst.heap32[r2 + numDefine108];
  heapClassInst.heap32[r1 + numDefine111] = heapClassInst.heap32[r2 + numDefine109];
  heapClassInst.heap32[r1 + numDefine112] = heapClassInst.heap32[r2 + numDefine110];
  r0 = heapClassInst.heapU8[r0 + numDefine444];
  heapClassInst.heap32[r1 + numDefine119] = r0;
  heapClassInst.heap32[r1 + numDefine113] = heapClassInst.heap32[r2 + numDefine112];
  heapClassInst.heap32[r1 + numDefine114] = heapClassInst.heap32[r2 + numDefine113];
  heapClassInst.heap32[r1 + numDefine115] = heapClassInst.heap32[r2 + numDefine114];
  heapClassInst.heap32[r1 + numDefine116] = heapClassInst.heap32[r2 + numDefine115];
  heapClassInst.heap32[r1 + numDefine117] = heapClassInst.heap32[r2 + numDefine116];
  heapClassInst.heap32[r1 + numDefine118] = heapClassInst.heap32[r2 + numDefine117];
  r0 = twoEStr414;
  commonVariable.rg0 = r0;
  return;
}

function zn11btRigidBody16addConstraintRefEP17btTypedConstraint(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let r10: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  r2 = heapClassInst.heap32[fp + 1];
  r3 = heapClassInst.heap32[r1 + numDefine120];
  r4 = 0;
  repeat1: while (true) {
    if (r3 > r4) {
      r5 = heapClassInst.heap32[r1 + numDefine122];
      r6 = r4 << numDefine2;
      r5 = (r5 + r6) | 0;
      r5 = r5 >> numDefine2;
      r5 = heapClassInst.heap32[r5];
      if (r5 !== r2) {
        r4 = (r4 + 1) | 0;
        continue repeat1;
      } else {
        label = numDefine5;
        break repeat1;
      }
    } else {
      label = numDefine4;
      break repeat1;
    }
  }
  if (label === numDefine4) {
    r4 = r3;
  }
  if (!(r3 !== r4)) {
    r4 = heapClassInst.heap32[r1 + numDefine121];
    if (r4 === r3) {
      r5 = 1;
      r6 = r3 << 1;
      r6 = r3 === 0 ? r5 : r6;
      if (!(r4 >= r6)) {
        if (r6 !== 0) {
          r4 = gNumAlignedAllocs;
          r4 = r4 >> numDefine2;
          r7 = heapClassInst.heap32[r4];
          r8 = r6 << numDefine2;
          r7 = (r7 + 1) | 0;
          r8 = r8 | numDefine3;
          heapClassInst.heap32[r4] = r7;
          r4 = (r8 + numDefine16) | 0;
          heapClassInst.heap32[g0] = r4;
          mallocNew(i7);
          r4 = commonVariable.rg0;
          if (r4 !== 0) {
            r7 = 0;
            r8 = (r4 + numDefine4) | 0;
            r7 = (r7 - r8) | 0;
            r7 = r7 & numDefine15;
            r7 = (r4 + r7) | 0;
            r8 = (r7 + numDefine4) | 0;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r7] = r4;
            r4 = r8;
          }
        } else {
          r4 = 0;
        }
        repeat18: do {
          if (r3 < 1) {
            r8 = heapClassInst.heap32[r1 + numDefine122];
          } else {
            r7 = 0;
            while (true) {
              r8 = heapClassInst.heap32[r1 + numDefine122];
              r9 = r7 << numDefine2;
              r10 = (r8 + r9) | 0;
              r10 = r10 >> numDefine2;
              r9 = (r4 + r9) | 0;
              r10 = heapClassInst.heap32[r10];
              r7 = (r7 + 1) | 0;
              r9 = r9 >> numDefine2;
              heapClassInst.heap32[r9] = r10;
              if (!(r3 !== r7)) {
                break repeat18;
              }
            }
          }
        } while (false);
        if (r8 !== 0) {
          r7 = heapClassInst.heapU8[r0 + numDefine492];
          if (r7 !== 0) {
            r3 = gNumAlignedFree;
            r3 = r3 >> numDefine2;
            r7 = heapClassInst.heap32[r3];
            r7 = (r7 + 1) | 0;
            r8 = r8 >> numDefine2;
            heapClassInst.heap32[r3] = r7;
            r3 = heapClassInst.heap32[r8 + -1];
            heapClassInst.heap32[g0] = r3;
            free(i7);
            r3 = heapClassInst.heap32[r1 + numDefine120];
          }
          heapClassInst.heap32[r1 + numDefine122] = 0;
        }
        heapClassInst.heap8[r0 + numDefine492] = r5;
        heapClassInst.heap32[r1 + numDefine122] = r4;
        heapClassInst.heap32[r1 + numDefine121] = r6;
      }
    }
    r0 = r3 << numDefine2;
    r3 = heapClassInst.heap32[r1 + numDefine122];
    r0 = (r3 + r0) | 0;
    r0 = r0 >> numDefine2;
    heapClassInst.heap32[r0] = r2;
    r0 = heapClassInst.heap32[r1 + numDefine120];
    r0 = (r0 + 1) | 0;
    heapClassInst.heap32[r1 + numDefine120] = r0;
  }
  heapClassInst.heap32[r1 + numDefine63] = 1;
  return;
}

function zn11btRigidBody19integrateVelocitiesEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let f9: number = 0.0;
  let f10: number = 0.0;
  let f11: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = heapClassInst.heapU8[r0 + numDefine204];
  r1 = r1 & numDefine3;
  if (!(r1 !== 0)) {
    f0 = heapClassInst.heapFloat[fp + 1];
    r0 = r0 >> numDefine2;
    f1 = heapClassInst.heapFloat[r0 + numDefine84];
    f1 = f1 * f0;
    f2 = heapClassInst.heapFloat[r0 + numDefine101];
    f3 = heapClassInst.heapFloat[r0 + numDefine103];
    f4 = heapClassInst.heapFloat[r0 + numDefine102];
    f5 = heapClassInst.heapFloat[r0 + numDefine76];
    f2 = f2 * f1;
    f2 = f5 + f2;
    heapClassInst.heapFloat[r0 + numDefine76] = f2;
    f2 = f4 * f1;
    f4 = heapClassInst.heapFloat[r0 + numDefine77];
    f2 = f4 + f2;
    heapClassInst.heapFloat[r0 + numDefine77] = f2;
    f1 = f3 * f1;
    f2 = heapClassInst.heapFloat[r0 + numDefine78];
    f1 = f2 + f1;
    heapClassInst.heapFloat[r0 + numDefine78] = f1;
    f1 = heapClassInst.heapFloat[r0 + numDefine105];
    f2 = heapClassInst.heapFloat[r0 + numDefine64];
    f3 = heapClassInst.heapFloat[r0 + numDefine106];
    f4 = heapClassInst.heapFloat[r0 + numDefine65];
    f2 = f2 * f1;
    f4 = f4 * f3;
    f5 = heapClassInst.heapFloat[r0 + numDefine107];
    f6 = heapClassInst.heapFloat[r0 + numDefine66];
    f2 = f2 + f4;
    f4 = f6 * f5;
    f2 = f2 + f4;
    f4 = heapClassInst.heapFloat[r0 + numDefine68];
    f6 = heapClassInst.heapFloat[r0 + numDefine69];
    f7 = heapClassInst.heapFloat[r0 + numDefine72];
    f8 = heapClassInst.heapFloat[r0 + numDefine73];
    f9 = heapClassInst.heapFloat[r0 + numDefine74];
    f10 = heapClassInst.heapFloat[r0 + numDefine70];
    f11 = heapClassInst.heapFloat[r0 + numDefine80];
    f2 = f2 * f0;
    f4 = f4 * f1;
    f6 = f6 * f3;
    f2 = f11 + f2;
    f4 = f4 + f6;
    f6 = f10 * f5;
    f4 = f4 + f6;
    heapClassInst.heapFloat[r0 + numDefine80] = f2;
    f1 = f7 * f1;
    f3 = f8 * f3;
    f4 = f4 * f0;
    f6 = heapClassInst.heapFloat[r0 + numDefine81];
    f4 = f6 + f4;
    f1 = f1 + f3;
    f3 = f9 * f5;
    f1 = f1 + f3;
    heapClassInst.heapFloat[r0 + numDefine81] = f4;
    f1 = f1 * f0;
    f3 = heapClassInst.heapFloat[r0 + numDefine82];
    f1 = f3 + f1;
    f2 = f2 * f2;
    f3 = f4 * f4;
    heapClassInst.heapFloat[r0 + numDefine82] = f1;
    f2 = f2 + f3;
    f1 = f1 * f1;
    f1 = f2 + f1;
    heapClassInst.heapFloat[g0] = f1;
    sqrtf(i7);
    f1 = commonVariable.fg0;
    f2 = f1 * f0;
    f3 = numDefineFloat566;
    if (!(f2 <= f3)) {
      f0 = f3 / f0;
      f0 = f0 / f1;
      f1 = heapClassInst.heapFloat[r0 + numDefine80];
      f1 = f1 * f0;
      heapClassInst.heapFloat[r0 + numDefine80] = f1;
      f1 = heapClassInst.heapFloat[r0 + numDefine81];
      f1 = f1 * f0;
      heapClassInst.heapFloat[r0 + numDefine81] = f1;
      f1 = heapClassInst.heapFloat[r0 + numDefine82];
      f0 = f1 * f0;
      heapClassInst.heapFloat[r0 + numDefine82] = f0;
    }
  }
  return;
}

function zn11btRigidBody12applyDampingEf(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let f0: number = 0.0;
  let f1: number = 0.0;
  let f2: number = 0.0;
  let f3: number = 0.0;
  let f4: number = 0.0;
  let f5: number = 0.0;
  let f6: number = 0.0;
  let f7: number = 0.0;
  let f8: number = 0.0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = r0 >> numDefine2;
  f0 = heapClassInst.heapFloat[r1 + numDefine109];
  f1 = 1;
  f2 = heapClassInst.heapFloat[fp + 1];
  f0 = f1 - f0;
  heapClassInst.heapFloat[g0] = f0;
  heapClassInst.heapFloat[g0 + 1] = f2;
  powf(i7);
  f3 = heapClassInst.heapFloat[r1 + numDefine76];
  f3 = f3 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine76] = f3;
  f3 = heapClassInst.heapFloat[r1 + numDefine77];
  f3 = f3 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine77] = f3;
  f3 = heapClassInst.heapFloat[r1 + numDefine78];
  f0 = f3 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine78] = f0;
  f0 = heapClassInst.heapFloat[r1 + numDefine110];
  f0 = f1 - f0;
  heapClassInst.heapFloat[g0] = f0;
  heapClassInst.heapFloat[g0 + 1] = f2;
  powf(i7);
  f2 = heapClassInst.heapFloat[r1 + numDefine80];
  f2 = f2 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine80] = f2;
  f3 = heapClassInst.heapFloat[r1 + numDefine81];
  f3 = f3 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine81] = f3;
  f4 = heapClassInst.heapFloat[r1 + numDefine82];
  f0 = f4 * commonVariable.fg0;
  heapClassInst.heapFloat[r1 + numDefine82] = f0;
  r0 = heapClassInst.heapU8[r0 + numDefine444];
  if (!(r0 === 0)) {
    f4 = f2 * f2;
    f5 = f3 * f3;
    f6 = heapClassInst.heapFloat[r1 + numDefine76];
    f4 = f4 + f5;
    f5 = f0 * f0;
    f4 = f4 + f5;
    f5 = heapClassInst.heapFloat[r1 + numDefine114];
    if (f4 < f5) {
      f4 = heapClassInst.heapFloat[r1 + numDefine77];
      f5 = heapClassInst.heapFloat[r1 + numDefine78];
      f7 = f6 * f6;
      f8 = f4 * f4;
      f7 = f7 + f8;
      f8 = f5 * f5;
      f7 = f7 + f8;
      f8 = heapClassInst.heapFloat[r1 + numDefine113];
      if (f7 < f8) {
        f7 = heapClassInst.heapFloat[r1 + numDefine112];
        f2 = f2 * f7;
        f3 = f3 * f7;
        heapClassInst.heapFloat[r1 + numDefine80] = f2;
        f0 = f0 * f7;
        heapClassInst.heapFloat[r1 + numDefine81] = f3;
        f6 = f6 * f7;
        heapClassInst.heapFloat[r1 + numDefine82] = f0;
        f4 = f4 * f7;
        heapClassInst.heapFloat[r1 + numDefine76] = f6;
        f5 = f5 * f7;
        heapClassInst.heapFloat[r1 + numDefine77] = f4;
        heapClassInst.heapFloat[r1 + numDefine78] = f5;
      }
    } else {
      f4 = heapClassInst.heapFloat[r1 + numDefine77];
      f5 = heapClassInst.heapFloat[r1 + numDefine78];
    }
    f0 = f6 * f6;
    f2 = f4 * f4;
    f0 = f0 + f2;
    f2 = f5 * f5;
    f0 = f0 + f2;
    heapClassInst.heapFloat[g0] = f0;
    sqrtf(i7);
    f0 = commonVariable.fg0;
    f2 = heapClassInst.heapFloat[r1 + numDefine109];
    if (!(f2 <= f0)) {
      f2 = numDefineFloat091;
      if (f0 <= f2) {
        heapClassInst.heap32[r1 + numDefine76] = 0;
        heapClassInst.heap32[r1 + numDefine77] = 0;
        heapClassInst.heap32[r1 + numDefine78] = 0;
        heapClassInst.heap32[r1 + numDefine79] = 0;
      } else {
        f0 = heapClassInst.heapFloat[r1 + numDefine76];
        f3 = heapClassInst.heapFloat[r1 + numDefine77];
        f4 = heapClassInst.heapFloat[r1 + numDefine78];
        f0 = f0 * f0;
        f3 = f3 * f3;
        f0 = f0 + f3;
        f3 = f4 * f4;
        f0 = f0 + f3;
        heapClassInst.heapFloat[g0] = f0;
        sqrtf(i7);
        f0 = f1 / commonVariable.fg0;
        f3 = heapClassInst.heapFloat[r1 + numDefine76];
        f4 = heapClassInst.heapFloat[r1 + numDefine77];
        f5 = f3 * f0;
        f6 = heapClassInst.heapFloat[r1 + numDefine78];
        f7 = f4 * f0;
        f5 = f5 * f2;
        f0 = f6 * f0;
        f7 = f7 * f2;
        f3 = f3 - f5;
        f0 = f0 * f2;
        f2 = f4 - f7;
        heapClassInst.heapFloat[r1 + numDefine76] = f3;
        f0 = f6 - f0;
        heapClassInst.heapFloat[r1 + numDefine77] = f2;
        heapClassInst.heapFloat[r1 + numDefine78] = f0;
      }
    }
    f0 = heapClassInst.heapFloat[r1 + numDefine80];
    f2 = heapClassInst.heapFloat[r1 + numDefine81];
    f3 = heapClassInst.heapFloat[r1 + numDefine82];
    f0 = f0 * f0;
    f2 = f2 * f2;
    f0 = f0 + f2;
    f2 = f3 * f3;
    f0 = f0 + f2;
    heapClassInst.heapFloat[g0] = f0;
    sqrtf(i7);
    f0 = commonVariable.fg0;
    f2 = heapClassInst.heapFloat[r1 + numDefine110];
    if (!(f2 <= f0)) {
      f2 = numDefineFloat091;
      if (f0 <= f2) {
        heapClassInst.heap32[r1 + numDefine80] = 0;
        heapClassInst.heap32[r1 + numDefine81] = 0;
        heapClassInst.heap32[r1 + numDefine82] = 0;
        heapClassInst.heap32[r1 + numDefine83] = 0;
      } else {
        f0 = heapClassInst.heapFloat[r1 + numDefine80];
        f3 = heapClassInst.heapFloat[r1 + numDefine81];
        f4 = heapClassInst.heapFloat[r1 + numDefine82];
        f0 = f0 * f0;
        f3 = f3 * f3;
        f0 = f0 + f3;
        f3 = f4 * f4;
        f0 = f0 + f3;
        heapClassInst.heapFloat[g0] = f0;
        sqrtf(i7);
        f0 = f1 / commonVariable.fg0;
        f1 = heapClassInst.heapFloat[r1 + numDefine80];
        f3 = heapClassInst.heapFloat[r1 + numDefine81];
        f4 = f1 * f0;
        f5 = heapClassInst.heapFloat[r1 + numDefine82];
        f6 = f3 * f0;
        f4 = f4 * f2;
        f0 = f5 * f0;
        f6 = f6 * f2;
        f1 = f1 - f4;
        f0 = f0 * f2;
        f2 = f3 - f6;
        heapClassInst.heapFloat[r1 + numDefine80] = f1;
        f0 = f5 - f0;
        heapClassInst.heapFloat[r1 + numDefine81] = f2;
        heapClassInst.heapFloat[r1 + numDefine82] = f0;
        return;
      }
    }
  }
  return;
}

function globalIzn7btClockC2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zl13gProfileClock2E0;
  heapClassInst.heap32[g0] = numDefine8;
  r0 = r0 >> numDefine2;
  znwj(i7);
  heapClassInst.heap32[r0] = commonVariable.rg0;
  heapClassInst.heap32[g0] = commonVariable.rg0;
  heapClassInst.heap32[g0 + 1] = 0;
  r0 = zn15CProfileManager4RootE;
  r1 = r0 >> numDefine2;
  r2 = twoEStr729;
  getTimeOfDay(i7);
  heapClassInst.heap32[r1] = r2;
  heapClassInst.heap32[r1 + 1] = 0;
  heapClassInst.heap32[r1 + numDefine2] = 0;
  heapClassInst.heap32[r1 + numDefine3] = 0;
  heapClassInst.heap32[r1 + numDefine4] = 0;
  heapClassInst.heap32[r1 + numDefine5] = 0;
  heapClassInst.heap32[r1 + numDefine6] = 0;
  heapClassInst.heap32[r1 + numDefine7] = 0;
  heapClassInst.heap32[g0] = r0;
  zn12CProfileNode5ResetEv(i7);
  return;
}

function globalDzn7btClockC2Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zn15CProfileManager4RootE;
  r1 = zl13gProfileClock2E0;
  heapClassInst.heap32[g0] = r0;
  r0 = r1 >> numDefine2;
  zn12CProfileNodeD1Ev(i7);
  r0 = heapClassInst.heap32[r0];
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn12CProfileNodeD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0 + numDefine6];
  if (!(r1 === 0)) {
    heapClassInst.heap32[g0] = r1;
    zn12CProfileNodeD1Ev(i7);
    heapClassInst.heap32[g0] = r1;
    zdlPv(i7);
  }
  r0 = heapClassInst.heap32[r0 + numDefine7];
  if (!(r0 === 0)) {
    heapClassInst.heap32[g0] = r0;
    zn12CProfileNodeD1Ev(i7);
    heapClassInst.heap32[g0] = r0;
    zdlPv(i7);
  }
  return;
}

function zn15CProfileManager5ResetEv(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg24;
  let g0 = i7 >> numDefine2;
  r0 = zl13gProfileClock2E0;
  r0 = r0 >> numDefine2;
  r1 = heapClassInst.heap32[r0];
  heapClassInst.heap32[g0] = r1;
  heapClassInst.heap32[g0 + 1] = 0;
  getTimeOfDay(i7);
  r1 = zn15CProfileManager4RootE;
  heapClassInst.heap32[g0] = r1;
  r1 = r1 >> numDefine2;
  zn12CProfileNode5ResetEv(i7);
  r2 = heapClassInst.heap32[r1 + 1];
  r2 = (r2 + 1) | 0;
  heapClassInst.heap32[r1 + 1] = r2;
  r2 = heapClassInst.heap32[r1 + numDefine4];
  r3 = (r2 + 1) | 0;
  heapClassInst.heap32[r1 + numDefine4] = r3;
  if (!(r2 !== 0)) {
    r2 = sp + numDefineNeg16;
    heapClassInst.heap32[g0] = r2;
    heapClassInst.heap32[g0 + 1] = 0;
    getTimeOfDay(i7);
    r0 = heapClassInst.heap32[r0];
    r0 = r0 >> numDefine2;
    r2 = r2 >> numDefine2;
    r3 = heapClassInst.heap32[fp + numDefineNeg4];
    r4 = heapClassInst.heap32[r0];
    r3 = (r3 - r4) | 0;
    r2 = heapClassInst.heap32[r2 + 1];
    r0 = heapClassInst.heap32[r0 + 1];
    r0 = (r2 - r0) | 0;
    r2 = (r3 * numDefineN6) | 0;
    r0 = (r0 + r2) | 0;
    heapClassInst.heap32[r1 + numDefine3] = r0;
  }
  r0 = zn15CProfileManager12FrameCounterE;
  r0 = r0 >> numDefine2;
  heapClassInst.heap32[r0] = 0;
  r0 = sp + numDefineNeg8;
  heapClassInst.heap32[g0] = r0;
  heapClassInst.heap32[g0 + 1] = 0;
  getTimeOfDay(i7);
  return;
}

function globalIzn4Rw9CatfindEPNS8RwCatE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let r4: number = 0;
  let r5: number = 0;
  let r6: number = 0;
  let r7: number = 0;
  let r8: number = 0;
  let r9: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zn4RwL12RwCatlistE2E0;
  r1 = zn4RwL12RwCatlistE2E1;
  r0 = r0 >> numDefine2;
  r2 = zn4RwL12RwCatlistE2E2;
  r1 = r1 >> numDefine2;
  heapClassInst.heap32[r0] = 0;
  r2 = r2 >> numDefine2;
  heapClassInst.heap32[r1] = 0;
  heapClassInst.heap32[r2] = 0;
  heapClassInst.heap32[g0] = numDefine136;
  znwj(i7);
  r3 = commonVariable.rg0;
  if (!(r3 !== 0)) {
    heapClassInst.heap32[g0] = numDefine3;
    zn4Rw10RwThrowEiz(i7);
  }
  r4 = (r3 + numDefine136) | 0;
  heapClassInst.heap32[g0] = 0;
  zdlPv(i7);
  r5 = heapClassInst.heap32[r0];
  if (r5 === 0) {
    r8 = r3;
  } else {
    r6 = r5;
    r7 = r3;
    repeat9: while (true) {
      r9 = r6 >> numDefine2;
      r6 = (r6 + numDefine4) | 0;
      r8 = (r7 + numDefine4) | 0;
      r7 = r7 >> numDefine2;
      r9 = heapClassInst.heap32[r9];
      heapClassInst.heap32[r7] = r9;
      r7 = r8;
      if (r6 !== 0) {
        continue repeat9;
      } else {
        break repeat9;
      }
    }
  }
  r6 = 0;
  repeat12: while (true) {
    r7 = r6 << numDefine2;
    r7 = (r8 + r7) | 0;
    r6 = (r6 + 1) | 0;
    r7 = r7 >> numDefine2;
    heapClassInst.heap32[r7] = 0;
    if (r6 !== numDefine2) {
      continue repeat12;
    } else {
      break repeat12;
    }
  }
  r6 = heapClassInst.heap32[r1];
  if (r6 === 0) {
    r6 = (r8 + numDefine8) | 0;
    heapClassInst.heap32[r0] = r3;
    heapClassInst.heap32[r1] = r6;
    heapClassInst.heap32[r2] = r4;
    heapClassInst.heap32[g0] = r5;
    zdlPv(i7);
    return;
  } else {
    abort(i7);
  }
}

function globalDzn4Rw9CatfindEPNS8RwCatE(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = zn4RwL12RwCatlistE2E0;
  r1 = zn4RwL12RwCatlistE2E1;
  r0 = r0 >> numDefine2;
  r1 = r1 >> numDefine2;
  r0 = heapClassInst.heap32[r0];
  r2 = heapClassInst.heap32[r1];
  r3 = (r2 - r0) | 0;
  r3 = r3 >> numDefine2;
  if (!(r3 === 0)) {
    r3 = r3 << numDefine2;
    r2 = (r2 - r3) | 0;
    heapClassInst.heap32[r1] = r2;
  }
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

function zn4Rw10RwFacetD1Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn4Rw10RwFacetE;
  r0 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r0] = r1;
  heapClassInst.heap32[r0 + numDefine5] = -1;
  r1 = heapClassInst.heap32[r0 + 1];
  r2 = heapClassInst.heap32[r0 + numDefine2];
  if (!(r1 === r2)) {
    if (!(r1 === 0)) {
      heapClassInst.heap32[g0] = r1;
      zdaPv(i7);
    }
  }
  r1 = zzn4Rw10RwFacetD4EvE9destroyed;
  heapClassInst.heap32[r0 + 1] = r1;
  r1 = heapClassInst.heap32[r0 + numDefine4];
  if (!(r1 !== -1)) {
    r0 = heapClassInst.heap32[r0 + numDefine3];
    heapClassInst.heap32[g0] = r0;
    zdlPv(i7);
  }
  return;
}

function zn4Rw10RwFacetD0Ev(sp: number): void {
  let i7: number = 0;
  let fp = sp >> numDefine2;
  let r0: number = 0;
  let r1: number = 0;
  let r2: number = 0;
  let r3: number = 0;
  let label = 0;
  i7 = sp + numDefineNeg8;
  let g0 = i7 >> numDefine2;
  r0 = heapClassInst.heap32[fp];
  r1 = ztvn4Rw10RwFacetE;
  r2 = r0 >> numDefine2;
  r1 = (r1 + numDefine8) | 0;
  heapClassInst.heap32[r2] = r1;
  heapClassInst.heap32[r2 + numDefine5] = -1;
  r1 = heapClassInst.heap32[r2 + 1];
  r3 = heapClassInst.heap32[r2 + numDefine2];
  if (!(r1 === r3)) {
    if (!(r1 === 0)) {
      heapClassInst.heap32[g0] = r1;
      zdaPv(i7);
    }
  }
  r1 = zzn4Rw10RwFacetD4EvE9destroyed;
  heapClassInst.heap32[r2 + 1] = r1;
  r1 = heapClassInst.heap32[r2 + numDefine4];
  if (!(r1 !== -1)) {
    r1 = heapClassInst.heap32[r2 + numDefine3];
    heapClassInst.heap32[g0] = r1;
    zdlPv(i7);
  }
  heapClassInst.heap32[g0] = r0;
  zdlPv(i7);
  return;
}

export { zn35btSequentialImpulseConstraintSolver36resolveSingleConstraintRowLowerLimitER11btRigidBodyS1RK18btSolverConstraint };

export { zn35btSequentialImpulseConstraintSolver43resolveSplitPenetrationImpulseCacheFriendlyER11btRigidBodyS1RK18btSolverConstraint };

export { z24applyAnisotropicFrictionP17btCollisionObjectR9btVector3, zn35btSequentialImpulseConstraintSolver5resetEv };

export { zn35btSequential };

export { zn35btSequentialImpulseConstraintSolverD1Ev, zn35btSequentialImpulseConstraintSolverD0Ev };

export { zn35btSolver10Solve };

export { zn35btSFriendly };

export { zn35btsConstraint };

export { zn35btSequentialImpulse };

export { zn35btSVector3P11 };

export { zn23btDiscreteDynamicsWorld11setNumTasksEi };

export { zn23btDiscreteDynamicsWorld14updateVehiclesEf, zn15btDynamicsWorld13addConstraintEP17btTypedConstraintb };

export { zn15btDynamicsWorld16removeConstraintEP17btTypedConstraint, znk15btDynamicsWorld17getNumConstraintsEv };

export { zn15btDynamicsWorld13getConstraintEi, znk15btDynamicsWorld13getConstraintEi };

export { zn15btDynamicsWorld10addVehicleEP17btActionInterface, zn15btDynamicsWorld13removeVehicleEP17btActionInterface };

export { zn15btDynamicsWorld12addCharacterEP17btActionInterface };

export { zn15btDynamicsWorld15removeCharacterEP17btActionInterface, znk23btDiscreteDynamicsWorld12getWorldTypeEv };

export { znk23btDiscreteDynamicsWorld10getGravityEv, zn23btDiscreteDynamicsWorld10addVehicleEP17btActionInterface };

export { zn23btDiscreteDynamicsWorld13removeVehicleEP17btActionInterface };

export { zn23btDiscreteDynamicsWorld12addCharacterEP17btActionInterface };

export { zn23btDiscreteDynamicsWorld15removeCharacterEP17btActionInterface, zn34btClosestNotMeConvexResultCallbackD1Ev };

export { zn34btClosestNotMeConvexResultCallbackD0Ev };

export { znk34btClosestNotMeConvexResultCallback14needsCollisionEP17btBroadphaseProxy };

export { zn34btClosestNotMeConvexResultCallback15addSingleResultERN16btCollisionWorld17LocalConvexResultEb };

export { zn23btDiscreteDynamicsWorld19getConstraintSolverEv, znk23btDiscreteDynamicsWorld17getNumConstraintsEv };

export { zn23btDiscreteDynamicsWorld13getConstraintEi, zn23btDiscreteDynamicsWorld11clearForcesEv };

export { znk23btDiscreteDynamicsWorld13getConstraintEi, zn23btDiscreteDynamicsWorld12removeActionEP17btActionInterface };

export { zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD1Ev };

export { zzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoEN27InplaceSolverIslandCallbackD0Ev };

export { zn35btDiscrete };

export { zn20btAlignedObjectArrayIP17btTypedConstraintE17quickSortInternalI33btSortConstraintOnIslandPredicateEEvTIi };

export { zn23btDiscreteDynamicsWorld9serializeEP12btSerializer };

export { zn23btDiscreteDynamicsWorld19setConstraintSolverEP18btConstraintSolver };

export { zn23btDiscreteDynamicsWorld25predictUnconstraintMotionEf };

export { zn23btDiscreteDynamicsWorld26calculateSimulationIslandsEv };

export { zn23btDiscreteDynamicsWorld9addActionEP17btActionInterface, zn23btDiscreteDynamicsWorld19integrateTransformsEf };

export { zn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfo };

export { zn23btDiscreteDynamicsWorld16removeConstraintEP17btTypedConstraint };

export { zn23btDiscreteDynamicsWorld13addConstraintEP17btTypedConstraintb };

export { zn23btDiscreteDynamicsWorld28internalSingleStepSimulationEf };

export { zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBodyss };

export { zn23btDiscreteDynamicsWorld12addRigidBodyEP11btRigidBody, zn23btDiscreteDynamicsWorld10setGravityERK9btVector3 };

export { zn23btDiscreteDynamicsWorld15removeRigidBodyEP11btRigidBody };

export { zn23btDiscreteDynamicsWorld21removeCollisionObjectEP17btCollisionObject };

export { zn23btDiscreteDynamicsWorld18addCollisionObjectEP17btCollisionObjectss };

export { zn23btDiscreteDynamicsWorld14stepSimulationEfif, zn23btDiscreteDynamicsWorld23synchronizeMotionStatesEv };

export { zn23btDiscreteDynamicsWorld12applyGravityEv, zn23btDiscreteDynamicsWorld14debugDrawWorldEv };

export { zn23btDiscreteDynamicsWorld18saveKinematicStateEf, zn15btDynamicsWorldD1Ev, zn15btDynamicsWorldD0Ev };

export { zn23btDiscreteDynamicsWorldD0Ev, zn23btDiscreteDynamicsWorldD1Ev };

export { znk11btRigidBody28calculateSerializeBufferSizeEv, znk11btRigidBody21serializeSingleObjectEP12btSerializer };

export { zn11btRigidBody24checkCollideWithOverrideEP17btCollisionObject, zn11btRigidBodyD0Ev, zn11btRigidBodyD1Ev };

export { znk11btRigidBody9serializeEPvP12btSerializer, globalIzn7btClockC2Ev, globalDzn7btClockC2Ev };

export { globalIzn4Rw9CatfindEPNS8RwCatE, globalDzn4Rw9CatfindEPNS8RwCatE };

export { zn4Rw10RwThrowEiz, zn4Rw10RwFacetD1Ev, zn4Rw10RwFacetD0Ev };

export { zn11btRigidBody14setupRigidBodyERKNS27btRigidBodyConstructionInfoE };
